1//===--- CGCXX.cpp - Emit LLVM Code for declarations ----------------------===//
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 contains code dealing with C++ code generation.
11//
12//===----------------------------------------------------------------------===//
13
14// We might split this into multiple files if it gets too unwieldy
15
16#include "CGCXXABI.h"
17#include "CodeGenFunction.h"
18#include "CodeGenModule.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/RecordLayout.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclObjC.h"
24#include "clang/AST/Mangle.h"
25#include "clang/AST/StmtCXX.h"
26#include "clang/Frontend/CodeGenOptions.h"
27#include "llvm/ADT/StringExtras.h"
28using namespace clang;
29using namespace CodeGen;
30
31/// Try to emit a base destructor as an alias to its primary
32/// base-class destructor.
33bool CodeGenModule::TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) {
34  if (!getCodeGenOpts().CXXCtorDtorAliases)
35    return true;
36
37  // If the destructor doesn't have a trivial body, we have to emit it
38  // separately.
39  if (!D->hasTrivialBody())
40    return true;
41
42  const CXXRecordDecl *Class = D->getParent();
43
44  // If we need to manipulate a VTT parameter, give up.
45  if (Class->getNumVBases()) {
46    // Extra Credit:  passing extra parameters is perfectly safe
47    // in many calling conventions, so only bail out if the ctor's
48    // calling convention is nonstandard.
49    return true;
50  }
51
52  // If any field has a non-trivial destructor, we have to emit the
53  // destructor separately.
54  for (CXXRecordDecl::field_iterator I = Class->field_begin(),
55         E = Class->field_end(); I != E; ++I)
56    if (I->getType().isDestructedType())
57      return true;
58
59  // Try to find a unique base class with a non-trivial destructor.
60  const CXXRecordDecl *UniqueBase = 0;
61  for (CXXRecordDecl::base_class_const_iterator I = Class->bases_begin(),
62         E = Class->bases_end(); I != E; ++I) {
63
64    // We're in the base destructor, so skip virtual bases.
65    if (I->isVirtual()) continue;
66
67    // Skip base classes with trivial destructors.
68    const CXXRecordDecl *Base
69      = cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
70    if (Base->hasTrivialDestructor()) continue;
71
72    // If we've already found a base class with a non-trivial
73    // destructor, give up.
74    if (UniqueBase) return true;
75    UniqueBase = Base;
76  }
77
78  // If we didn't find any bases with a non-trivial destructor, then
79  // the base destructor is actually effectively trivial, which can
80  // happen if it was needlessly user-defined or if there are virtual
81  // bases with non-trivial destructors.
82  if (!UniqueBase)
83    return true;
84
85  /// If we don't have a definition for the destructor yet, don't
86  /// emit.  We can't emit aliases to declarations; that's just not
87  /// how aliases work.
88  const CXXDestructorDecl *BaseD = UniqueBase->getDestructor();
89  if (!BaseD->isImplicit() && !BaseD->hasBody())
90    return true;
91
92  // If the base is at a non-zero offset, give up.
93  const ASTRecordLayout &ClassLayout = Context.getASTRecordLayout(Class);
94  if (!ClassLayout.getBaseClassOffset(UniqueBase).isZero())
95    return true;
96
97  return TryEmitDefinitionAsAlias(GlobalDecl(D, Dtor_Base),
98                                  GlobalDecl(BaseD, Dtor_Base));
99}
100
101/// Try to emit a definition as a global alias for another definition.
102bool CodeGenModule::TryEmitDefinitionAsAlias(GlobalDecl AliasDecl,
103                                             GlobalDecl TargetDecl) {
104  if (!getCodeGenOpts().CXXCtorDtorAliases)
105    return true;
106
107  // The alias will use the linkage of the referrent.  If we can't
108  // support aliases with that linkage, fail.
109  llvm::GlobalValue::LinkageTypes Linkage
110    = getFunctionLinkage(cast<FunctionDecl>(AliasDecl.getDecl()));
111
112  switch (Linkage) {
113  // We can definitely emit aliases to definitions with external linkage.
114  case llvm::GlobalValue::ExternalLinkage:
115  case llvm::GlobalValue::ExternalWeakLinkage:
116    break;
117
118  // Same with local linkage.
119  case llvm::GlobalValue::InternalLinkage:
120  case llvm::GlobalValue::PrivateLinkage:
121  case llvm::GlobalValue::LinkerPrivateLinkage:
122    break;
123
124  // We should try to support linkonce linkages.
125  case llvm::GlobalValue::LinkOnceAnyLinkage:
126  case llvm::GlobalValue::LinkOnceODRLinkage:
127    return true;
128
129  // Other linkages will probably never be supported.
130  default:
131    return true;
132  }
133
134  llvm::GlobalValue::LinkageTypes TargetLinkage
135    = getFunctionLinkage(cast<FunctionDecl>(TargetDecl.getDecl()));
136
137  if (llvm::GlobalValue::isWeakForLinker(TargetLinkage))
138    return true;
139
140  // Derive the type for the alias.
141  llvm::PointerType *AliasType
142    = getTypes().GetFunctionType(AliasDecl)->getPointerTo();
143
144  // Find the referrent.  Some aliases might require a bitcast, in
145  // which case the caller is responsible for ensuring the soundness
146  // of these semantics.
147  llvm::GlobalValue *Ref = cast<llvm::GlobalValue>(GetAddrOfGlobal(TargetDecl));
148  llvm::Constant *Aliasee = Ref;
149  if (Ref->getType() != AliasType)
150    Aliasee = llvm::ConstantExpr::getBitCast(Ref, AliasType);
151
152  // Create the alias with no name.
153  llvm::GlobalAlias *Alias =
154    new llvm::GlobalAlias(AliasType, Linkage, "", Aliasee, &getModule());
155
156  // Switch any previous uses to the alias.
157  StringRef MangledName = getMangledName(AliasDecl);
158  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
159  if (Entry) {
160    assert(Entry->isDeclaration() && "definition already exists for alias");
161    assert(Entry->getType() == AliasType &&
162           "declaration exists with different type");
163    Alias->takeName(Entry);
164    Entry->replaceAllUsesWith(Alias);
165    Entry->eraseFromParent();
166  } else {
167    Alias->setName(MangledName);
168  }
169
170  // Finally, set up the alias with its proper name and attributes.
171  SetCommonAttributes(cast<NamedDecl>(AliasDecl.getDecl()), Alias);
172
173  return false;
174}
175
176void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
177  // The constructor used for constructing this as a complete class;
178  // constucts the virtual bases, then calls the base constructor.
179  if (!D->getParent()->isAbstract()) {
180    // We don't need to emit the complete ctor if the class is abstract.
181    EmitGlobal(GlobalDecl(D, Ctor_Complete));
182  }
183
184  // The constructor used for constructing this as a base class;
185  // ignores virtual bases.
186  EmitGlobal(GlobalDecl(D, Ctor_Base));
187}
188
189void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *ctor,
190                                       CXXCtorType ctorType) {
191  // The complete constructor is equivalent to the base constructor
192  // for classes with no virtual bases.  Try to emit it as an alias.
193  if (ctorType == Ctor_Complete &&
194      !ctor->getParent()->getNumVBases() &&
195      !TryEmitDefinitionAsAlias(GlobalDecl(ctor, Ctor_Complete),
196                                GlobalDecl(ctor, Ctor_Base)))
197    return;
198
199  const CGFunctionInfo &fnInfo =
200    getTypes().arrangeCXXConstructorDeclaration(ctor, ctorType);
201
202  llvm::Function *fn =
203    cast<llvm::Function>(GetAddrOfCXXConstructor(ctor, ctorType, &fnInfo));
204  setFunctionLinkage(ctor, fn);
205
206  CodeGenFunction(*this).GenerateCode(GlobalDecl(ctor, ctorType), fn, fnInfo);
207
208  SetFunctionDefinitionAttributes(ctor, fn);
209  SetLLVMFunctionAttributesForDefinition(ctor, fn);
210}
211
212llvm::GlobalValue *
213CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *ctor,
214                                       CXXCtorType ctorType,
215                                       const CGFunctionInfo *fnInfo) {
216  GlobalDecl GD(ctor, ctorType);
217
218  StringRef name = getMangledName(GD);
219  if (llvm::GlobalValue *existing = GetGlobalValue(name))
220    return existing;
221
222  if (!fnInfo)
223    fnInfo = &getTypes().arrangeCXXConstructorDeclaration(ctor, ctorType);
224
225  llvm::FunctionType *fnType = getTypes().GetFunctionType(*fnInfo);
226  return cast<llvm::Function>(GetOrCreateLLVMFunction(name, fnType, GD,
227                                                      /*ForVTable=*/false));
228}
229
230void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
231  // The destructor in a virtual table is always a 'deleting'
232  // destructor, which calls the complete destructor and then uses the
233  // appropriate operator delete.
234  if (D->isVirtual())
235    EmitGlobal(GlobalDecl(D, Dtor_Deleting));
236
237  // The destructor used for destructing this as a most-derived class;
238  // call the base destructor and then destructs any virtual bases.
239  EmitGlobal(GlobalDecl(D, Dtor_Complete));
240
241  // The destructor used for destructing this as a base class; ignores
242  // virtual bases.
243  EmitGlobal(GlobalDecl(D, Dtor_Base));
244}
245
246void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *dtor,
247                                      CXXDtorType dtorType) {
248  // The complete destructor is equivalent to the base destructor for
249  // classes with no virtual bases, so try to emit it as an alias.
250  if (dtorType == Dtor_Complete &&
251      !dtor->getParent()->getNumVBases() &&
252      !TryEmitDefinitionAsAlias(GlobalDecl(dtor, Dtor_Complete),
253                                GlobalDecl(dtor, Dtor_Base)))
254    return;
255
256  // The base destructor is equivalent to the base destructor of its
257  // base class if there is exactly one non-virtual base class with a
258  // non-trivial destructor, there are no fields with a non-trivial
259  // destructor, and the body of the destructor is trivial.
260  if (dtorType == Dtor_Base && !TryEmitBaseDestructorAsAlias(dtor))
261    return;
262
263  const CGFunctionInfo &fnInfo =
264    getTypes().arrangeCXXDestructor(dtor, dtorType);
265
266  llvm::Function *fn =
267    cast<llvm::Function>(GetAddrOfCXXDestructor(dtor, dtorType, &fnInfo));
268  setFunctionLinkage(dtor, fn);
269
270  CodeGenFunction(*this).GenerateCode(GlobalDecl(dtor, dtorType), fn, fnInfo);
271
272  SetFunctionDefinitionAttributes(dtor, fn);
273  SetLLVMFunctionAttributesForDefinition(dtor, fn);
274}
275
276llvm::GlobalValue *
277CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *dtor,
278                                      CXXDtorType dtorType,
279                                      const CGFunctionInfo *fnInfo) {
280  GlobalDecl GD(dtor, dtorType);
281
282  StringRef name = getMangledName(GD);
283  if (llvm::GlobalValue *existing = GetGlobalValue(name))
284    return existing;
285
286  if (!fnInfo) fnInfo = &getTypes().arrangeCXXDestructor(dtor, dtorType);
287
288  llvm::FunctionType *fnType = getTypes().GetFunctionType(*fnInfo);
289  return cast<llvm::Function>(GetOrCreateLLVMFunction(name, fnType, GD,
290                                                      /*ForVTable=*/false));
291}
292
293static llvm::Value *BuildVirtualCall(CodeGenFunction &CGF, uint64_t VTableIndex,
294                                     llvm::Value *This, llvm::Type *Ty) {
295  Ty = Ty->getPointerTo()->getPointerTo();
296
297  llvm::Value *VTable = CGF.GetVTablePtr(This, Ty);
298  llvm::Value *VFuncPtr =
299    CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
300  return CGF.Builder.CreateLoad(VFuncPtr);
301}
302
303llvm::Value *
304CodeGenFunction::BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
305                                  llvm::Type *Ty) {
306  MD = MD->getCanonicalDecl();
307  uint64_t VTableIndex = CGM.getVTableContext().getMethodVTableIndex(MD);
308
309  return ::BuildVirtualCall(*this, VTableIndex, This, Ty);
310}
311
312/// BuildVirtualCall - This routine is to support gcc's kext ABI making
313/// indirect call to virtual functions. It makes the call through indexing
314/// into the vtable.
315llvm::Value *
316CodeGenFunction::BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
317                                  NestedNameSpecifier *Qual,
318                                  llvm::Type *Ty) {
319  llvm::Value *VTable = 0;
320  assert((Qual->getKind() == NestedNameSpecifier::TypeSpec) &&
321         "BuildAppleKextVirtualCall - bad Qual kind");
322
323  const Type *QTy = Qual->getAsType();
324  QualType T = QualType(QTy, 0);
325  const RecordType *RT = T->getAs<RecordType>();
326  assert(RT && "BuildAppleKextVirtualCall - Qual type must be record");
327  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
328
329  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD))
330    return BuildAppleKextVirtualDestructorCall(DD, Dtor_Complete, RD);
331
332  VTable = CGM.getVTables().GetAddrOfVTable(RD);
333  Ty = Ty->getPointerTo()->getPointerTo();
334  VTable = Builder.CreateBitCast(VTable, Ty);
335  assert(VTable && "BuildVirtualCall = kext vtbl pointer is null");
336  MD = MD->getCanonicalDecl();
337  uint64_t VTableIndex = CGM.getVTableContext().getMethodVTableIndex(MD);
338  uint64_t AddressPoint =
339    CGM.getVTableContext().getVTableLayout(RD)
340       .getAddressPoint(BaseSubobject(RD, CharUnits::Zero()));
341  VTableIndex += AddressPoint;
342  llvm::Value *VFuncPtr =
343    Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfnkxt");
344  return Builder.CreateLoad(VFuncPtr);
345}
346
347/// BuildVirtualCall - This routine makes indirect vtable call for
348/// call to virtual destructors. It returns 0 if it could not do it.
349llvm::Value *
350CodeGenFunction::BuildAppleKextVirtualDestructorCall(
351                                            const CXXDestructorDecl *DD,
352                                            CXXDtorType Type,
353                                            const CXXRecordDecl *RD) {
354  llvm::Value * Callee = 0;
355  const CXXMethodDecl *MD = cast<CXXMethodDecl>(DD);
356  // FIXME. Dtor_Base dtor is always direct!!
357  // It need be somehow inline expanded into the caller.
358  // -O does that. But need to support -O0 as well.
359  if (MD->isVirtual() && Type != Dtor_Base) {
360    // Compute the function type we're calling.
361    const CGFunctionInfo &FInfo =
362      CGM.getTypes().arrangeCXXDestructor(cast<CXXDestructorDecl>(MD),
363                                          Dtor_Complete);
364    llvm::Type *Ty = CGM.getTypes().GetFunctionType(FInfo);
365
366    llvm::Value *VTable = CGM.getVTables().GetAddrOfVTable(RD);
367    Ty = Ty->getPointerTo()->getPointerTo();
368    VTable = Builder.CreateBitCast(VTable, Ty);
369    DD = cast<CXXDestructorDecl>(DD->getCanonicalDecl());
370    uint64_t VTableIndex =
371      CGM.getVTableContext().getMethodVTableIndex(GlobalDecl(DD, Type));
372    uint64_t AddressPoint =
373      CGM.getVTableContext().getVTableLayout(RD)
374         .getAddressPoint(BaseSubobject(RD, CharUnits::Zero()));
375    VTableIndex += AddressPoint;
376    llvm::Value *VFuncPtr =
377      Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfnkxt");
378    Callee = Builder.CreateLoad(VFuncPtr);
379  }
380  return Callee;
381}
382
383llvm::Value *
384CodeGenFunction::BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
385                                  llvm::Value *This, llvm::Type *Ty) {
386  DD = cast<CXXDestructorDecl>(DD->getCanonicalDecl());
387  uint64_t VTableIndex =
388    CGM.getVTableContext().getMethodVTableIndex(GlobalDecl(DD, Type));
389
390  return ::BuildVirtualCall(*this, VTableIndex, This, Ty);
391}
392
393