CGCXX.cpp revision 5a8503b333f50acd6012859853612229f38cb420 
1//===--- CGDecl.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 "CodeGenFunction.h"
17#include "CodeGenModule.h"
18#include "Mangle.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 "llvm/ADT/StringExtras.h"
25using namespace clang;
26using namespace CodeGen;
27
28void
29CodeGenFunction::GenerateStaticCXXBlockVarDeclInit(const VarDecl &D,
30                                                   llvm::GlobalVariable *GV) {
31  // FIXME: This should use __cxa_guard_{acquire,release}?
32
33  assert(!getContext().getLangOptions().ThreadsafeStatics &&
34         "thread safe statics are currently not supported!");
35
36  llvm::SmallString<256> GuardVName;
37  llvm::raw_svector_ostream GuardVOut(GuardVName);
38  mangleGuardVariable(&D, getContext(), GuardVOut);
39
40  // Create the guard variable.
41  llvm::GlobalValue *GuardV =
42    new llvm::GlobalVariable(CGM.getModule(), llvm::Type::Int64Ty, false,
43                             GV->getLinkage(),
44                             VMContext.getNullValue(llvm::Type::Int64Ty),
45                             GuardVName.c_str());
46
47  // Load the first byte of the guard variable.
48  const llvm::Type *PtrTy = VMContext.getPointerType(llvm::Type::Int8Ty, 0);
49  llvm::Value *V = Builder.CreateLoad(Builder.CreateBitCast(GuardV, PtrTy),
50                                      "tmp");
51
52  // Compare it against 0.
53  llvm::Value *nullValue = VMContext.getNullValue(llvm::Type::Int8Ty);
54  llvm::Value *ICmp = Builder.CreateICmpEQ(V, nullValue , "tobool");
55
56  llvm::BasicBlock *InitBlock = createBasicBlock("init");
57  llvm::BasicBlock *EndBlock = createBasicBlock("init.end");
58
59  // If the guard variable is 0, jump to the initializer code.
60  Builder.CreateCondBr(ICmp, InitBlock, EndBlock);
61
62  EmitBlock(InitBlock);
63
64  const Expr *Init = D.getInit();
65  if (!hasAggregateLLVMType(Init->getType())) {
66    llvm::Value *V = EmitScalarExpr(Init);
67    Builder.CreateStore(V, GV, D.getType().isVolatileQualified());
68  } else if (Init->getType()->isAnyComplexType()) {
69    EmitComplexExprIntoAddr(Init, GV, D.getType().isVolatileQualified());
70  } else {
71    EmitAggExpr(Init, GV, D.getType().isVolatileQualified());
72  }
73
74  Builder.CreateStore(llvm::ConstantInt::get(llvm::Type::Int8Ty, 1),
75                      Builder.CreateBitCast(GuardV, PtrTy));
76
77  EmitBlock(EndBlock);
78}
79
80RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
81                                          llvm::Value *Callee,
82                                          llvm::Value *This,
83                                          CallExpr::const_arg_iterator ArgBeg,
84                                          CallExpr::const_arg_iterator ArgEnd) {
85  assert(MD->isInstance() &&
86         "Trying to emit a member call expr on a static method!");
87
88  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
89
90  CallArgList Args;
91
92  // Push the this ptr.
93  Args.push_back(std::make_pair(RValue::get(This),
94                                MD->getThisType(getContext())));
95
96  // And the rest of the call args
97  EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
98
99  QualType ResultType = MD->getType()->getAsFunctionType()->getResultType();
100  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args),
101                  Callee, Args, MD);
102}
103
104RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE) {
105  const MemberExpr *ME = cast<MemberExpr>(CE->getCallee());
106  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
107
108  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
109  const llvm::Type *Ty =
110    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
111                                   FPT->isVariadic());
112  llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty);
113
114  llvm::Value *This;
115
116  if (ME->isArrow())
117    This = EmitScalarExpr(ME->getBase());
118  else {
119    LValue BaseLV = EmitLValue(ME->getBase());
120    This = BaseLV.getAddress();
121  }
122
123  return EmitCXXMemberCall(MD, Callee, This,
124                           CE->arg_begin(), CE->arg_end());
125}
126
127RValue
128CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
129                                               const CXXMethodDecl *MD) {
130  assert(MD->isInstance() &&
131         "Trying to emit a member call expr on a static method!");
132
133
134  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
135  const llvm::Type *Ty =
136  CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
137                                 FPT->isVariadic());
138  llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty);
139
140  llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
141
142  return EmitCXXMemberCall(MD, Callee, This,
143                           E->arg_begin() + 1, E->arg_end());
144}
145
146llvm::Value *CodeGenFunction::LoadCXXThis() {
147  assert(isa<CXXMethodDecl>(CurFuncDecl) &&
148         "Must be in a C++ member function decl to load 'this'");
149  assert(cast<CXXMethodDecl>(CurFuncDecl)->isInstance() &&
150         "Must be in a C++ member function decl to load 'this'");
151
152  // FIXME: What if we're inside a block?
153  // ans: See how CodeGenFunction::LoadObjCSelf() uses
154  // CodeGenFunction::BlockForwardSelf() for how to do this.
155  return Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this");
156}
157
158llvm::Value *CodeGenFunction::AddressCXXOfBaseClass(llvm::Value *BaseValue,
159                                          const CXXRecordDecl *ClassDecl,
160                                          const CXXRecordDecl *BaseClassDecl) {
161  if (ClassDecl == BaseClassDecl)
162    return BaseValue;
163
164  // Accessing a member of the base class. Must add delata to
165  // the load of 'this'.
166  // FIXME. Once type layout is complete, this will probably change.
167  const ASTRecordLayout &Layout =
168  getContext().getASTRecordLayout(ClassDecl);
169  llvm::Type *I8Ptr = VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty);
170  uint64_t Offset = Layout.getBaseClassOffset(BaseClassDecl) / 8;
171  llvm::Value *OffsetVal =
172    llvm::ConstantInt::get(
173                  CGM.getTypes().ConvertType(CGM.getContext().LongTy), Offset);
174  BaseValue = Builder.CreateBitCast(BaseValue, I8Ptr);
175  BaseValue = Builder.CreateGEP(BaseValue, OffsetVal, "add.ptr");
176  QualType BTy =
177    getContext().getCanonicalType(
178      getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(BaseClassDecl)));
179  const llvm::Type *BasePtr = ConvertType(BTy);
180  BasePtr = VMContext.getPointerTypeUnqual(BasePtr);
181  BaseValue = Builder.CreateBitCast(BaseValue, BasePtr);
182  return BaseValue;
183}
184
185void
186CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
187                                        CXXCtorType Type,
188                                        llvm::Value *This,
189                                        CallExpr::const_arg_iterator ArgBeg,
190                                        CallExpr::const_arg_iterator ArgEnd) {
191  llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
192
193  EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd);
194}
195
196void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D,
197                                            CXXDtorType Type,
198                                            llvm::Value *This) {
199  llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type);
200
201  EmitCXXMemberCall(D, Callee, This, 0, 0);
202}
203
204void
205CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
206                                      const CXXConstructExpr *E) {
207  assert(Dest && "Must have a destination!");
208
209  const CXXRecordDecl *RD =
210  cast<CXXRecordDecl>(E->getType()->getAsRecordType()->getDecl());
211  if (RD->hasTrivialConstructor())
212    return;
213
214  // Call the constructor.
215  EmitCXXConstructorCall(E->getConstructor(), Ctor_Complete, Dest,
216                         E->arg_begin(), E->arg_end());
217}
218
219llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
220  if (E->isArray()) {
221    ErrorUnsupported(E, "new[] expression");
222    return VMContext.getUndef(ConvertType(E->getType()));
223  }
224
225  QualType AllocType = E->getAllocatedType();
226  FunctionDecl *NewFD = E->getOperatorNew();
227  const FunctionProtoType *NewFTy = NewFD->getType()->getAsFunctionProtoType();
228
229  CallArgList NewArgs;
230
231  // The allocation size is the first argument.
232  QualType SizeTy = getContext().getSizeType();
233  llvm::Value *AllocSize =
234    llvm::ConstantInt::get(ConvertType(SizeTy),
235                           getContext().getTypeSize(AllocType) / 8);
236
237  NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy));
238
239  // Emit the rest of the arguments.
240  // FIXME: Ideally, this should just use EmitCallArgs.
241  CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin();
242
243  // First, use the types from the function type.
244  // We start at 1 here because the first argument (the allocation size)
245  // has already been emitted.
246  for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) {
247    QualType ArgType = NewFTy->getArgType(i);
248
249    assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
250           getTypePtr() ==
251           getContext().getCanonicalType(NewArg->getType()).getTypePtr() &&
252           "type mismatch in call argument!");
253
254    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
255                                     ArgType));
256
257  }
258
259  // Either we've emitted all the call args, or we have a call to a
260  // variadic function.
261  assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) &&
262         "Extra arguments in non-variadic function!");
263
264  // If we still have any arguments, emit them using the type of the argument.
265  for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end();
266       NewArg != NewArgEnd; ++NewArg) {
267    QualType ArgType = NewArg->getType();
268    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
269                                     ArgType));
270  }
271
272  // Emit the call to new.
273  RValue RV =
274    EmitCall(CGM.getTypes().getFunctionInfo(NewFTy->getResultType(), NewArgs),
275             CGM.GetAddrOfFunction(GlobalDecl(NewFD)),
276             NewArgs, NewFD);
277
278  // If an allocation function is declared with an empty exception specification
279  // it returns null to indicate failure to allocate storage. [expr.new]p13.
280  // (We don't need to check for null when there's no new initializer and
281  // we're allocating a POD type).
282  bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() &&
283    !(AllocType->isPODType() && !E->hasInitializer());
284
285  llvm::BasicBlock *NewNull = 0;
286  llvm::BasicBlock *NewNotNull = 0;
287  llvm::BasicBlock *NewEnd = 0;
288
289  llvm::Value *NewPtr = RV.getScalarVal();
290
291  if (NullCheckResult) {
292    NewNull = createBasicBlock("new.null");
293    NewNotNull = createBasicBlock("new.notnull");
294    NewEnd = createBasicBlock("new.end");
295
296    llvm::Value *IsNull =
297      Builder.CreateICmpEQ(NewPtr,
298                           VMContext.getNullValue(NewPtr->getType()),
299                           "isnull");
300
301    Builder.CreateCondBr(IsNull, NewNull, NewNotNull);
302    EmitBlock(NewNotNull);
303  }
304
305  NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
306
307  if (AllocType->isPODType()) {
308    if (E->getNumConstructorArgs() > 0) {
309      assert(E->getNumConstructorArgs() == 1 &&
310             "Can only have one argument to initializer of POD type.");
311
312      const Expr *Init = E->getConstructorArg(0);
313
314      if (!hasAggregateLLVMType(AllocType))
315        Builder.CreateStore(EmitScalarExpr(Init), NewPtr);
316      else if (AllocType->isAnyComplexType())
317        EmitComplexExprIntoAddr(Init, NewPtr, AllocType.isVolatileQualified());
318      else
319        EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified());
320    }
321  } else {
322    // Call the constructor.
323    CXXConstructorDecl *Ctor = E->getConstructor();
324
325    EmitCXXConstructorCall(Ctor, Ctor_Complete, NewPtr,
326                           E->constructor_arg_begin(),
327                           E->constructor_arg_end());
328  }
329
330  if (NullCheckResult) {
331    Builder.CreateBr(NewEnd);
332    EmitBlock(NewNull);
333    Builder.CreateBr(NewEnd);
334    EmitBlock(NewEnd);
335
336    llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
337    PHI->reserveOperandSpace(2);
338    PHI->addIncoming(NewPtr, NewNotNull);
339    PHI->addIncoming(VMContext.getNullValue(NewPtr->getType()), NewNull);
340
341    NewPtr = PHI;
342  }
343
344  return NewPtr;
345}
346
347static bool canGenerateCXXstructor(const CXXRecordDecl *RD,
348                                   ASTContext &Context) {
349  // The class has base classes - we don't support that right now.
350  if (RD->getNumBases() > 0)
351    return false;
352
353  for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
354         I != E; ++I) {
355    // We don't support ctors for fields that aren't POD.
356    if (!I->getType()->isPODType())
357      return false;
358  }
359
360  return true;
361}
362
363void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
364  if (!canGenerateCXXstructor(D->getParent(), getContext())) {
365    ErrorUnsupported(D, "C++ constructor", true);
366    return;
367  }
368
369  EmitGlobal(GlobalDecl(D, Ctor_Complete));
370  EmitGlobal(GlobalDecl(D, Ctor_Base));
371}
372
373void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D,
374                                       CXXCtorType Type) {
375
376  llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type);
377
378  CodeGenFunction(*this).GenerateCode(D, Fn);
379
380  SetFunctionDefinitionAttributes(D, Fn);
381  SetLLVMFunctionAttributesForDefinition(D, Fn);
382}
383
384llvm::Function *
385CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D,
386                                       CXXCtorType Type) {
387  const llvm::FunctionType *FTy =
388    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
389
390  const char *Name = getMangledCXXCtorName(D, Type);
391  return cast<llvm::Function>(
392                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
393}
394
395const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D,
396                                                 CXXCtorType Type) {
397  llvm::SmallString<256> Name;
398  llvm::raw_svector_ostream Out(Name);
399  mangleCXXCtor(D, Type, Context, Out);
400
401  Name += '\0';
402  return UniqueMangledName(Name.begin(), Name.end());
403}
404
405void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
406  if (!canGenerateCXXstructor(D->getParent(), getContext())) {
407    ErrorUnsupported(D, "C++ destructor", true);
408    return;
409  }
410
411  EmitCXXDestructor(D, Dtor_Complete);
412  EmitCXXDestructor(D, Dtor_Base);
413}
414
415void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D,
416                                      CXXDtorType Type) {
417  llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type);
418
419  CodeGenFunction(*this).GenerateCode(D, Fn);
420
421  SetFunctionDefinitionAttributes(D, Fn);
422  SetLLVMFunctionAttributesForDefinition(D, Fn);
423}
424
425llvm::Function *
426CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D,
427                                      CXXDtorType Type) {
428  const llvm::FunctionType *FTy =
429    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
430
431  const char *Name = getMangledCXXDtorName(D, Type);
432  return cast<llvm::Function>(
433                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
434}
435
436const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D,
437                                                 CXXDtorType Type) {
438  llvm::SmallString<256> Name;
439  llvm::raw_svector_ostream Out(Name);
440  mangleCXXDtor(D, Type, Context, Out);
441
442  Name += '\0';
443  return UniqueMangledName(Name.begin(), Name.end());
444}
445
446/// EmitCtorPrologue - This routine generates necessary code to initialize
447/// base classes and non-static data members belonging to this constructor.
448void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD) {
449  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
450  assert(ClassDecl->vbases_begin() == ClassDecl->vbases_end()
451         && "FIXME. virtual base initialization unsupported");
452
453  for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
454       E = CD->init_end();
455       B != E; ++B) {
456    CXXBaseOrMemberInitializer *Member = (*B);
457    if (Member->isBaseInitializer()) {
458      llvm::Value *LoadOfThis = LoadCXXThis();
459      Type *BaseType = Member->getBaseClass();
460      CXXRecordDecl *BaseClassDecl =
461        cast<CXXRecordDecl>(BaseType->getAsRecordType()->getDecl());
462      llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl,
463                                             BaseClassDecl);
464      EmitCXXConstructorCall(Member->getConstructor(),
465                             Ctor_Complete, V,
466                             Member->const_arg_begin(),
467                             Member->const_arg_end());
468    }
469    else {
470      // non-static data member initilaizers.
471      FieldDecl *Field = Member->getMember();
472      QualType FieldType = getContext().getCanonicalType((Field)->getType());
473      assert(!getContext().getAsArrayType(FieldType)
474             && "FIXME. Field arrays initialization unsupported");
475
476      llvm::Value *LoadOfThis = LoadCXXThis();
477      LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
478      if (FieldType->getAsRecordType()) {
479
480          assert(Member->getConstructor() &&
481                 "EmitCtorPrologue - no constructor to initialize member");
482          EmitCXXConstructorCall(Member->getConstructor(),
483                                 Ctor_Complete, LHS.getAddress(),
484                                 Member->const_arg_begin(),
485                                 Member->const_arg_end());
486        continue;
487      }
488
489      assert(Member->getNumArgs() == 1 && "Initializer count must be 1 only");
490      Expr *RhsExpr = *Member->arg_begin();
491      llvm::Value *RHS = EmitScalarExpr(RhsExpr, true);
492      if (LHS.isBitfield())
493        EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, FieldType, 0);
494      else
495        EmitStoreThroughLValue(RValue::get(RHS), LHS, FieldType);
496    }
497  }
498}
499