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