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 "CodeGenModule.h"
17#include "CGCXXABI.h"
18#include "CodeGenFunction.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/Mangle.h"
24#include "clang/AST/RecordLayout.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 = getFunctionLinkage(AliasDecl);
110
111  switch (Linkage) {
112  // We can definitely emit aliases to definitions with external linkage.
113  case llvm::GlobalValue::ExternalLinkage:
114  case llvm::GlobalValue::ExternalWeakLinkage:
115    break;
116
117  // Same with local linkage.
118  case llvm::GlobalValue::InternalLinkage:
119  case llvm::GlobalValue::PrivateLinkage:
120  case llvm::GlobalValue::LinkerPrivateLinkage:
121    break;
122
123  // We should try to support linkonce linkages.
124  case llvm::GlobalValue::LinkOnceAnyLinkage:
125  case llvm::GlobalValue::LinkOnceODRLinkage:
126    return true;
127
128  // Other linkages will probably never be supported.
129  default:
130    return true;
131  }
132
133  llvm::GlobalValue::LinkageTypes TargetLinkage
134    = getFunctionLinkage(TargetDecl);
135
136  if (llvm::GlobalValue::isWeakForLinker(TargetLinkage))
137    return true;
138
139  // Derive the type for the alias.
140  llvm::PointerType *AliasType
141    = getTypes().GetFunctionType(AliasDecl)->getPointerTo();
142
143  // Find the referrent.  Some aliases might require a bitcast, in
144  // which case the caller is responsible for ensuring the soundness
145  // of these semantics.
146  llvm::GlobalValue *Ref = cast<llvm::GlobalValue>(GetAddrOfGlobal(TargetDecl));
147  llvm::Constant *Aliasee = Ref;
148  if (Ref->getType() != AliasType)
149    Aliasee = llvm::ConstantExpr::getBitCast(Ref, AliasType);
150
151  // Create the alias with no name.
152  llvm::GlobalAlias *Alias =
153    new llvm::GlobalAlias(AliasType, Linkage, "", Aliasee, &getModule());
154
155  // Switch any previous uses to the alias.
156  StringRef MangledName = getMangledName(AliasDecl);
157  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
158  if (Entry) {
159    assert(Entry->isDeclaration() && "definition already exists for alias");
160    assert(Entry->getType() == AliasType &&
161           "declaration exists with different type");
162    Alias->takeName(Entry);
163    Entry->replaceAllUsesWith(Alias);
164    Entry->eraseFromParent();
165  } else {
166    Alias->setName(MangledName);
167  }
168
169  // Finally, set up the alias with its proper name and attributes.
170  SetCommonAttributes(cast<NamedDecl>(AliasDecl.getDecl()), Alias);
171
172  return false;
173}
174
175void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *ctor,
176                                       CXXCtorType ctorType) {
177  // The complete constructor is equivalent to the base constructor
178  // for classes with no virtual bases.  Try to emit it as an alias.
179  if (getTarget().getCXXABI().hasConstructorVariants() &&
180      ctorType == Ctor_Complete &&
181      !ctor->getParent()->getNumVBases() &&
182      !TryEmitDefinitionAsAlias(GlobalDecl(ctor, Ctor_Complete),
183                                GlobalDecl(ctor, Ctor_Base)))
184    return;
185
186  const CGFunctionInfo &fnInfo =
187    getTypes().arrangeCXXConstructorDeclaration(ctor, ctorType);
188
189  llvm::Function *fn =
190    cast<llvm::Function>(GetAddrOfCXXConstructor(ctor, ctorType, &fnInfo));
191  setFunctionLinkage(GlobalDecl(ctor, ctorType), fn);
192
193  CodeGenFunction(*this).GenerateCode(GlobalDecl(ctor, ctorType), fn, fnInfo);
194
195  SetFunctionDefinitionAttributes(ctor, fn);
196  SetLLVMFunctionAttributesForDefinition(ctor, fn);
197}
198
199llvm::GlobalValue *
200CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *ctor,
201                                       CXXCtorType ctorType,
202                                       const CGFunctionInfo *fnInfo) {
203  GlobalDecl GD(ctor, ctorType);
204
205  StringRef name = getMangledName(GD);
206  if (llvm::GlobalValue *existing = GetGlobalValue(name))
207    return existing;
208
209  if (!fnInfo)
210    fnInfo = &getTypes().arrangeCXXConstructorDeclaration(ctor, ctorType);
211
212  llvm::FunctionType *fnType = getTypes().GetFunctionType(*fnInfo);
213  return cast<llvm::Function>(GetOrCreateLLVMFunction(name, fnType, GD,
214                                                      /*ForVTable=*/false));
215}
216
217void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *dtor,
218                                      CXXDtorType dtorType) {
219  // The complete destructor is equivalent to the base destructor for
220  // classes with no virtual bases, so try to emit it as an alias.
221  if (dtorType == Dtor_Complete &&
222      !dtor->getParent()->getNumVBases() &&
223      !TryEmitDefinitionAsAlias(GlobalDecl(dtor, Dtor_Complete),
224                                GlobalDecl(dtor, Dtor_Base)))
225    return;
226
227  // The base destructor is equivalent to the base destructor of its
228  // base class if there is exactly one non-virtual base class with a
229  // non-trivial destructor, there are no fields with a non-trivial
230  // destructor, and the body of the destructor is trivial.
231  if (dtorType == Dtor_Base && !TryEmitBaseDestructorAsAlias(dtor))
232    return;
233
234  const CGFunctionInfo &fnInfo =
235    getTypes().arrangeCXXDestructor(dtor, dtorType);
236
237  llvm::Function *fn =
238    cast<llvm::Function>(GetAddrOfCXXDestructor(dtor, dtorType, &fnInfo));
239  setFunctionLinkage(GlobalDecl(dtor, dtorType), fn);
240
241  CodeGenFunction(*this).GenerateCode(GlobalDecl(dtor, dtorType), fn, fnInfo);
242
243  SetFunctionDefinitionAttributes(dtor, fn);
244  SetLLVMFunctionAttributesForDefinition(dtor, fn);
245}
246
247llvm::GlobalValue *
248CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *dtor,
249                                      CXXDtorType dtorType,
250                                      const CGFunctionInfo *fnInfo,
251                                      llvm::FunctionType *fnType) {
252  // If the class has no virtual bases, then the complete and base destructors
253  // are equivalent, for all C++ ABIs supported by clang.  We can save on code
254  // size by calling the base dtor directly, especially if we'd have to emit a
255  // thunk otherwise.
256  // FIXME: We should do this for Itanium, after verifying that nothing breaks.
257  if (dtorType == Dtor_Complete && dtor->getParent()->getNumVBases() == 0 &&
258      getCXXABI().useThunkForDtorVariant(dtor, Dtor_Complete))
259    dtorType = Dtor_Base;
260
261  GlobalDecl GD(dtor, dtorType);
262
263  StringRef name = getMangledName(GD);
264  if (llvm::GlobalValue *existing = GetGlobalValue(name))
265    return existing;
266
267  if (!fnType) {
268    if (!fnInfo) fnInfo = &getTypes().arrangeCXXDestructor(dtor, dtorType);
269    fnType = getTypes().GetFunctionType(*fnInfo);
270  }
271  return cast<llvm::Function>(GetOrCreateLLVMFunction(name, fnType, GD,
272                                                      /*ForVTable=*/false));
273}
274
275llvm::Value *
276CodeGenFunction::BuildVirtualCall(GlobalDecl GD, llvm::Value *This,
277                                  llvm::Type *Ty) {
278  GD = GD.getCanonicalDecl();
279  uint64_t VTableIndex = CGM.getVTableContext().getMethodVTableIndex(GD);
280
281  Ty = Ty->getPointerTo()->getPointerTo();
282  llvm::Value *VTable = GetVTablePtr(This, Ty);
283  llvm::Value *VFuncPtr =
284    Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
285  return Builder.CreateLoad(VFuncPtr);
286}
287
288static llvm::Value *BuildAppleKextVirtualCall(CodeGenFunction &CGF,
289                                              GlobalDecl GD,
290                                              llvm::Type *Ty,
291                                              const CXXRecordDecl *RD) {
292  GD = GD.getCanonicalDecl();
293  CodeGenModule &CGM = CGF.CGM;
294  llvm::Value *VTable = CGM.getVTables().GetAddrOfVTable(RD);
295  Ty = Ty->getPointerTo()->getPointerTo();
296  VTable = CGF.Builder.CreateBitCast(VTable, Ty);
297  assert(VTable && "BuildVirtualCall = kext vtbl pointer is null");
298  uint64_t VTableIndex = CGM.getVTableContext().getMethodVTableIndex(GD);
299  uint64_t AddressPoint =
300    CGM.getVTableContext().getVTableLayout(RD)
301       .getAddressPoint(BaseSubobject(RD, CharUnits::Zero()));
302  VTableIndex += AddressPoint;
303  llvm::Value *VFuncPtr =
304    CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfnkxt");
305  return CGF.Builder.CreateLoad(VFuncPtr);
306}
307
308/// BuildAppleKextVirtualCall - This routine is to support gcc's kext ABI making
309/// indirect call to virtual functions. It makes the call through indexing
310/// into the vtable.
311llvm::Value *
312CodeGenFunction::BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
313                                  NestedNameSpecifier *Qual,
314                                  llvm::Type *Ty) {
315  assert((Qual->getKind() == NestedNameSpecifier::TypeSpec) &&
316         "BuildAppleKextVirtualCall - bad Qual kind");
317
318  const Type *QTy = Qual->getAsType();
319  QualType T = QualType(QTy, 0);
320  const RecordType *RT = T->getAs<RecordType>();
321  assert(RT && "BuildAppleKextVirtualCall - Qual type must be record");
322  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
323
324  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD))
325    return BuildAppleKextVirtualDestructorCall(DD, Dtor_Complete, RD);
326
327  return ::BuildAppleKextVirtualCall(*this, MD, Ty, RD);
328}
329
330/// BuildVirtualCall - This routine makes indirect vtable call for
331/// call to virtual destructors. It returns 0 if it could not do it.
332llvm::Value *
333CodeGenFunction::BuildAppleKextVirtualDestructorCall(
334                                            const CXXDestructorDecl *DD,
335                                            CXXDtorType Type,
336                                            const CXXRecordDecl *RD) {
337  const CXXMethodDecl *MD = cast<CXXMethodDecl>(DD);
338  // FIXME. Dtor_Base dtor is always direct!!
339  // It need be somehow inline expanded into the caller.
340  // -O does that. But need to support -O0 as well.
341  if (MD->isVirtual() && Type != Dtor_Base) {
342    // Compute the function type we're calling.
343    const CGFunctionInfo &FInfo =
344      CGM.getTypes().arrangeCXXDestructor(DD, Dtor_Complete);
345    llvm::Type *Ty = CGM.getTypes().GetFunctionType(FInfo);
346    return ::BuildAppleKextVirtualCall(*this, GlobalDecl(DD, Type), Ty, RD);
347  }
348  return 0;
349}
350