CGCXX.cpp revision dbd0900ac3de45ac86fe87453a946096f2f8ef2b 
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
275static llvm::Value *BuildAppleKextVirtualCall(CodeGenFunction &CGF,
276                                              GlobalDecl GD,
277                                              llvm::Type *Ty,
278                                              const CXXRecordDecl *RD) {
279  assert(!CGF.CGM.getTarget().getCXXABI().isMicrosoft() &&
280         "No kext in Microsoft ABI");
281  GD = GD.getCanonicalDecl();
282  CodeGenModule &CGM = CGF.CGM;
283  llvm::Value *VTable = CGM.getCXXABI().getAddrOfVTable(RD, CharUnits());
284  Ty = Ty->getPointerTo()->getPointerTo();
285  VTable = CGF.Builder.CreateBitCast(VTable, Ty);
286  assert(VTable && "BuildVirtualCall = kext vtbl pointer is null");
287  uint64_t VTableIndex = CGM.getVTableContext().getMethodVTableIndex(GD);
288  uint64_t AddressPoint =
289    CGM.getVTableContext().getVTableLayout(RD)
290       .getAddressPoint(BaseSubobject(RD, CharUnits::Zero()));
291  VTableIndex += AddressPoint;
292  llvm::Value *VFuncPtr =
293    CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfnkxt");
294  return CGF.Builder.CreateLoad(VFuncPtr);
295}
296
297/// BuildAppleKextVirtualCall - This routine is to support gcc's kext ABI making
298/// indirect call to virtual functions. It makes the call through indexing
299/// into the vtable.
300llvm::Value *
301CodeGenFunction::BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
302                                  NestedNameSpecifier *Qual,
303                                  llvm::Type *Ty) {
304  assert((Qual->getKind() == NestedNameSpecifier::TypeSpec) &&
305         "BuildAppleKextVirtualCall - bad Qual kind");
306
307  const Type *QTy = Qual->getAsType();
308  QualType T = QualType(QTy, 0);
309  const RecordType *RT = T->getAs<RecordType>();
310  assert(RT && "BuildAppleKextVirtualCall - Qual type must be record");
311  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
312
313  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD))
314    return BuildAppleKextVirtualDestructorCall(DD, Dtor_Complete, RD);
315
316  return ::BuildAppleKextVirtualCall(*this, MD, Ty, RD);
317}
318
319/// BuildVirtualCall - This routine makes indirect vtable call for
320/// call to virtual destructors. It returns 0 if it could not do it.
321llvm::Value *
322CodeGenFunction::BuildAppleKextVirtualDestructorCall(
323                                            const CXXDestructorDecl *DD,
324                                            CXXDtorType Type,
325                                            const CXXRecordDecl *RD) {
326  const CXXMethodDecl *MD = cast<CXXMethodDecl>(DD);
327  // FIXME. Dtor_Base dtor is always direct!!
328  // It need be somehow inline expanded into the caller.
329  // -O does that. But need to support -O0 as well.
330  if (MD->isVirtual() && Type != Dtor_Base) {
331    // Compute the function type we're calling.
332    const CGFunctionInfo &FInfo =
333      CGM.getTypes().arrangeCXXDestructor(DD, Dtor_Complete);
334    llvm::Type *Ty = CGM.getTypes().GetFunctionType(FInfo);
335    return ::BuildAppleKextVirtualCall(*this, GlobalDecl(DD, Type), Ty, RD);
336  }
337  return 0;
338}
339