CodeGenFunction.cpp revision f315fa81eef1977b3457fd7a7d4639e060fe7278 
1//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
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 coordinates the per-function state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
16#include "CGCXXABI.h"
17#include "CGDebugInfo.h"
18#include "CGException.h"
19#include "clang/Basic/TargetInfo.h"
20#include "clang/AST/APValue.h"
21#include "clang/AST/ASTContext.h"
22#include "clang/AST/Decl.h"
23#include "clang/AST/DeclCXX.h"
24#include "clang/AST/StmtCXX.h"
25#include "clang/Frontend/CodeGenOptions.h"
26#include "llvm/Target/TargetData.h"
27#include "llvm/Intrinsics.h"
28using namespace clang;
29using namespace CodeGen;
30
31CodeGenFunction::CodeGenFunction(CodeGenModule &cgm)
32  : CGM(cgm), Target(CGM.getContext().Target),
33    Builder(cgm.getModule().getContext()),
34    BlockInfo(0), BlockPointer(0),
35    NormalCleanupDest(0), EHCleanupDest(0), NextCleanupDestIndex(1),
36    ExceptionSlot(0), DebugInfo(0), IndirectBranch(0),
37    SwitchInsn(0), CaseRangeBlock(0),
38    DidCallStackSave(false), UnreachableBlock(0),
39    CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0),
40    OutermostConditional(0), TerminateLandingPad(0), TerminateHandler(0),
41    TrapBB(0) {
42
43  // Get some frequently used types.
44  LLVMPointerWidth = Target.getPointerWidth(0);
45  llvm::LLVMContext &LLVMContext = CGM.getLLVMContext();
46  IntPtrTy = llvm::IntegerType::get(LLVMContext, LLVMPointerWidth);
47  Int32Ty  = llvm::Type::getInt32Ty(LLVMContext);
48  Int64Ty  = llvm::Type::getInt64Ty(LLVMContext);
49  Int8PtrTy = cgm.Int8PtrTy;
50
51  Exceptions = getContext().getLangOptions().Exceptions;
52  CatchUndefined = getContext().getLangOptions().CatchUndefined;
53  CGM.getCXXABI().getMangleContext().startNewFunction();
54}
55
56ASTContext &CodeGenFunction::getContext() const {
57  return CGM.getContext();
58}
59
60
61const llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
62  return CGM.getTypes().ConvertTypeForMem(T);
63}
64
65const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
66  return CGM.getTypes().ConvertType(T);
67}
68
69bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
70  return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() ||
71    T->isObjCObjectType();
72}
73
74void CodeGenFunction::EmitReturnBlock() {
75  // For cleanliness, we try to avoid emitting the return block for
76  // simple cases.
77  llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
78
79  if (CurBB) {
80    assert(!CurBB->getTerminator() && "Unexpected terminated block.");
81
82    // We have a valid insert point, reuse it if it is empty or there are no
83    // explicit jumps to the return block.
84    if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
85      ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
86      delete ReturnBlock.getBlock();
87    } else
88      EmitBlock(ReturnBlock.getBlock());
89    return;
90  }
91
92  // Otherwise, if the return block is the target of a single direct
93  // branch then we can just put the code in that block instead. This
94  // cleans up functions which started with a unified return block.
95  if (ReturnBlock.getBlock()->hasOneUse()) {
96    llvm::BranchInst *BI =
97      dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin());
98    if (BI && BI->isUnconditional() &&
99        BI->getSuccessor(0) == ReturnBlock.getBlock()) {
100      // Reset insertion point and delete the branch.
101      Builder.SetInsertPoint(BI->getParent());
102      BI->eraseFromParent();
103      delete ReturnBlock.getBlock();
104      return;
105    }
106  }
107
108  // FIXME: We are at an unreachable point, there is no reason to emit the block
109  // unless it has uses. However, we still need a place to put the debug
110  // region.end for now.
111
112  EmitBlock(ReturnBlock.getBlock());
113}
114
115static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
116  if (!BB) return;
117  if (!BB->use_empty())
118    return CGF.CurFn->getBasicBlockList().push_back(BB);
119  delete BB;
120}
121
122void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
123  assert(BreakContinueStack.empty() &&
124         "mismatched push/pop in break/continue stack!");
125
126  // Emit function epilog (to return).
127  EmitReturnBlock();
128
129  if (ShouldInstrumentFunction())
130    EmitFunctionInstrumentation("__cyg_profile_func_exit");
131
132  // Emit debug descriptor for function end.
133  if (CGDebugInfo *DI = getDebugInfo()) {
134    DI->setLocation(EndLoc);
135    DI->EmitFunctionEnd(Builder);
136  }
137
138  EmitFunctionEpilog(*CurFnInfo);
139  EmitEndEHSpec(CurCodeDecl);
140
141  assert(EHStack.empty() &&
142         "did not remove all scopes from cleanup stack!");
143
144  // If someone did an indirect goto, emit the indirect goto block at the end of
145  // the function.
146  if (IndirectBranch) {
147    EmitBlock(IndirectBranch->getParent());
148    Builder.ClearInsertionPoint();
149  }
150
151  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
152  llvm::Instruction *Ptr = AllocaInsertPt;
153  AllocaInsertPt = 0;
154  Ptr->eraseFromParent();
155
156  // If someone took the address of a label but never did an indirect goto, we
157  // made a zero entry PHI node, which is illegal, zap it now.
158  if (IndirectBranch) {
159    llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
160    if (PN->getNumIncomingValues() == 0) {
161      PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
162      PN->eraseFromParent();
163    }
164  }
165
166  EmitIfUsed(*this, RethrowBlock.getBlock());
167  EmitIfUsed(*this, TerminateLandingPad);
168  EmitIfUsed(*this, TerminateHandler);
169  EmitIfUsed(*this, UnreachableBlock);
170
171  if (CGM.getCodeGenOpts().EmitDeclMetadata)
172    EmitDeclMetadata();
173}
174
175/// ShouldInstrumentFunction - Return true if the current function should be
176/// instrumented with __cyg_profile_func_* calls
177bool CodeGenFunction::ShouldInstrumentFunction() {
178  if (!CGM.getCodeGenOpts().InstrumentFunctions)
179    return false;
180  if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
181    return false;
182  return true;
183}
184
185/// EmitFunctionInstrumentation - Emit LLVM code to call the specified
186/// instrumentation function with the current function and the call site, if
187/// function instrumentation is enabled.
188void CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) {
189  const llvm::PointerType *PointerTy;
190  const llvm::FunctionType *FunctionTy;
191  std::vector<const llvm::Type*> ProfileFuncArgs;
192
193  // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site);
194  PointerTy = Int8PtrTy;
195  ProfileFuncArgs.push_back(PointerTy);
196  ProfileFuncArgs.push_back(PointerTy);
197  FunctionTy = llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()),
198                                       ProfileFuncArgs, false);
199
200  llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn);
201  llvm::CallInst *CallSite = Builder.CreateCall(
202    CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0),
203    llvm::ConstantInt::get(Int32Ty, 0),
204    "callsite");
205
206  Builder.CreateCall2(F,
207                      llvm::ConstantExpr::getBitCast(CurFn, PointerTy),
208                      CallSite);
209}
210
211void CodeGenFunction::EmitMCountInstrumentation() {
212  llvm::FunctionType *FTy =
213    llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), false);
214
215  llvm::Constant *MCountFn = CGM.CreateRuntimeFunction(FTy,
216                                                       Target.getMCountName());
217  Builder.CreateCall(MCountFn);
218}
219
220void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
221                                    llvm::Function *Fn,
222                                    const FunctionArgList &Args,
223                                    SourceLocation StartLoc) {
224  const Decl *D = GD.getDecl();
225
226  DidCallStackSave = false;
227  CurCodeDecl = CurFuncDecl = D;
228  FnRetTy = RetTy;
229  CurFn = Fn;
230  assert(CurFn->isDeclaration() && "Function already has body?");
231
232  // Pass inline keyword to optimizer if it appears explicitly on any
233  // declaration.
234  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
235    for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(),
236           RE = FD->redecls_end(); RI != RE; ++RI)
237      if (RI->isInlineSpecified()) {
238        Fn->addFnAttr(llvm::Attribute::InlineHint);
239        break;
240      }
241
242  if (getContext().getLangOptions().OpenCL) {
243    // Add metadata for a kernel function.
244    if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
245      if (FD->hasAttr<OpenCLKernelAttr>()) {
246        llvm::LLVMContext &Context = getLLVMContext();
247        llvm::NamedMDNode *OpenCLMetadata =
248          CGM.getModule().getOrInsertNamedMetadata("opencl.kernels");
249
250        llvm::Value *Op = Fn;
251        OpenCLMetadata->addOperand(llvm::MDNode::get(Context, &Op, 1));
252      }
253  }
254
255  llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
256
257  // Create a marker to make it easy to insert allocas into the entryblock
258  // later.  Don't create this with the builder, because we don't want it
259  // folded.
260  llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
261  AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB);
262  if (Builder.isNamePreserving())
263    AllocaInsertPt->setName("allocapt");
264
265  ReturnBlock = getJumpDestInCurrentScope("return");
266
267  Builder.SetInsertPoint(EntryBB);
268
269  // Emit subprogram debug descriptor.
270  if (CGDebugInfo *DI = getDebugInfo()) {
271    // FIXME: what is going on here and why does it ignore all these
272    // interesting type properties?
273    QualType FnType =
274      getContext().getFunctionType(RetTy, 0, 0,
275                                   FunctionProtoType::ExtProtoInfo());
276
277    DI->setLocation(StartLoc);
278    DI->EmitFunctionStart(GD, FnType, CurFn, Builder);
279  }
280
281  if (ShouldInstrumentFunction())
282    EmitFunctionInstrumentation("__cyg_profile_func_enter");
283
284  if (CGM.getCodeGenOpts().InstrumentForProfiling)
285    EmitMCountInstrumentation();
286
287  // FIXME: Leaked.
288  // CC info is ignored, hopefully?
289  CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args,
290                                              FunctionType::ExtInfo());
291
292  if (RetTy->isVoidType()) {
293    // Void type; nothing to return.
294    ReturnValue = 0;
295  } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect &&
296             hasAggregateLLVMType(CurFnInfo->getReturnType())) {
297    // Indirect aggregate return; emit returned value directly into sret slot.
298    // This reduces code size, and affects correctness in C++.
299    ReturnValue = CurFn->arg_begin();
300  } else {
301    ReturnValue = CreateIRTemp(RetTy, "retval");
302  }
303
304  EmitStartEHSpec(CurCodeDecl);
305  EmitFunctionProlog(*CurFnInfo, CurFn, Args);
306
307  if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance())
308    CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
309
310  // If any of the arguments have a variably modified type, make sure to
311  // emit the type size.
312  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
313       i != e; ++i) {
314    QualType Ty = i->second;
315
316    if (Ty->isVariablyModifiedType())
317      EmitVLASize(Ty);
318  }
319}
320
321void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) {
322  const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl());
323  assert(FD->getBody());
324  EmitStmt(FD->getBody());
325}
326
327/// Tries to mark the given function nounwind based on the
328/// non-existence of any throwing calls within it.  We believe this is
329/// lightweight enough to do at -O0.
330static void TryMarkNoThrow(llvm::Function *F) {
331  // LLVM treats 'nounwind' on a function as part of the type, so we
332  // can't do this on functions that can be overwritten.
333  if (F->mayBeOverridden()) return;
334
335  for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
336    for (llvm::BasicBlock::iterator
337           BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
338      if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI))
339        if (!Call->doesNotThrow())
340          return;
341  F->setDoesNotThrow(true);
342}
343
344void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) {
345  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
346
347  // Check if we should generate debug info for this function.
348  if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>())
349    DebugInfo = CGM.getDebugInfo();
350
351  FunctionArgList Args;
352  QualType ResTy = FD->getResultType();
353
354  CurGD = GD;
355  if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance())
356    CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args);
357
358  if (FD->getNumParams()) {
359    const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>();
360    assert(FProto && "Function def must have prototype!");
361
362    for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
363      Args.push_back(std::make_pair(FD->getParamDecl(i),
364                                    FProto->getArgType(i)));
365  }
366
367  SourceRange BodyRange;
368  if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
369
370  // Emit the standard function prologue.
371  StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin());
372
373  // Generate the body of the function.
374  if (isa<CXXDestructorDecl>(FD))
375    EmitDestructorBody(Args);
376  else if (isa<CXXConstructorDecl>(FD))
377    EmitConstructorBody(Args);
378  else
379    EmitFunctionBody(Args);
380
381  // Emit the standard function epilogue.
382  FinishFunction(BodyRange.getEnd());
383
384  // If we haven't marked the function nothrow through other means, do
385  // a quick pass now to see if we can.
386  if (!CurFn->doesNotThrow())
387    TryMarkNoThrow(CurFn);
388}
389
390/// ContainsLabel - Return true if the statement contains a label in it.  If
391/// this statement is not executed normally, it not containing a label means
392/// that we can just remove the code.
393bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
394  // Null statement, not a label!
395  if (S == 0) return false;
396
397  // If this is a label, we have to emit the code, consider something like:
398  // if (0) {  ...  foo:  bar(); }  goto foo;
399  if (isa<LabelStmt>(S))
400    return true;
401
402  // If this is a case/default statement, and we haven't seen a switch, we have
403  // to emit the code.
404  if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
405    return true;
406
407  // If this is a switch statement, we want to ignore cases below it.
408  if (isa<SwitchStmt>(S))
409    IgnoreCaseStmts = true;
410
411  // Scan subexpressions for verboten labels.
412  for (Stmt::const_child_range I = S->children(); I; ++I)
413    if (ContainsLabel(*I, IgnoreCaseStmts))
414      return true;
415
416  return false;
417}
418
419
420/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to
421/// a constant, or if it does but contains a label, return 0.  If it constant
422/// folds to 'true' and does not contain a label, return 1, if it constant folds
423/// to 'false' and does not contain a label, return -1.
424int CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) {
425  // FIXME: Rename and handle conversion of other evaluatable things
426  // to bool.
427  Expr::EvalResult Result;
428  if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() ||
429      Result.HasSideEffects)
430    return 0;  // Not foldable, not integer or not fully evaluatable.
431
432  if (CodeGenFunction::ContainsLabel(Cond))
433    return 0;  // Contains a label.
434
435  return Result.Val.getInt().getBoolValue() ? 1 : -1;
436}
437
438
439/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
440/// statement) to the specified blocks.  Based on the condition, this might try
441/// to simplify the codegen of the conditional based on the branch.
442///
443void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
444                                           llvm::BasicBlock *TrueBlock,
445                                           llvm::BasicBlock *FalseBlock) {
446  if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond))
447    return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock);
448
449  if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
450    // Handle X && Y in a condition.
451    if (CondBOp->getOpcode() == BO_LAnd) {
452      // If we have "1 && X", simplify the code.  "0 && X" would have constant
453      // folded if the case was simple enough.
454      if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) {
455        // br(1 && X) -> br(X).
456        return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
457      }
458
459      // If we have "X && 1", simplify the code to use an uncond branch.
460      // "X && 0" would have been constant folded to 0.
461      if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) {
462        // br(X && 1) -> br(X).
463        return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
464      }
465
466      // Emit the LHS as a conditional.  If the LHS conditional is false, we
467      // want to jump to the FalseBlock.
468      llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
469
470      ConditionalEvaluation eval(*this);
471      EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock);
472      EmitBlock(LHSTrue);
473
474      // Any temporaries created here are conditional.
475      eval.begin(*this);
476      EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
477      eval.end(*this);
478
479      return;
480    } else if (CondBOp->getOpcode() == BO_LOr) {
481      // If we have "0 || X", simplify the code.  "1 || X" would have constant
482      // folded if the case was simple enough.
483      if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) {
484        // br(0 || X) -> br(X).
485        return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
486      }
487
488      // If we have "X || 0", simplify the code to use an uncond branch.
489      // "X || 1" would have been constant folded to 1.
490      if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) {
491        // br(X || 0) -> br(X).
492        return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
493      }
494
495      // Emit the LHS as a conditional.  If the LHS conditional is true, we
496      // want to jump to the TrueBlock.
497      llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
498
499      ConditionalEvaluation eval(*this);
500      EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse);
501      EmitBlock(LHSFalse);
502
503      // Any temporaries created here are conditional.
504      eval.begin(*this);
505      EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
506      eval.end(*this);
507
508      return;
509    }
510  }
511
512  if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
513    // br(!x, t, f) -> br(x, f, t)
514    if (CondUOp->getOpcode() == UO_LNot)
515      return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock);
516  }
517
518  if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
519    // Handle ?: operator.
520
521    // Just ignore GNU ?: extension.
522    if (CondOp->getLHS()) {
523      // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
524      llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
525      llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
526
527      ConditionalEvaluation cond(*this);
528      EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock);
529
530      cond.begin(*this);
531      EmitBlock(LHSBlock);
532      EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock);
533      cond.end(*this);
534
535      cond.begin(*this);
536      EmitBlock(RHSBlock);
537      EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock);
538      cond.end(*this);
539
540      return;
541    }
542  }
543
544  // Emit the code with the fully general case.
545  llvm::Value *CondV = EvaluateExprAsBool(Cond);
546  Builder.CreateCondBr(CondV, TrueBlock, FalseBlock);
547}
548
549/// ErrorUnsupported - Print out an error that codegen doesn't support the
550/// specified stmt yet.
551void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type,
552                                       bool OmitOnError) {
553  CGM.ErrorUnsupported(S, Type, OmitOnError);
554}
555
556/// emitNonZeroVLAInit - Emit the "zero" initialization of a
557/// variable-length array whose elements have a non-zero bit-pattern.
558///
559/// \param src - a char* pointing to the bit-pattern for a single
560/// base element of the array
561/// \param sizeInChars - the total size of the VLA, in chars
562/// \param align - the total alignment of the VLA
563static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
564                               llvm::Value *dest, llvm::Value *src,
565                               llvm::Value *sizeInChars) {
566  std::pair<CharUnits,CharUnits> baseSizeAndAlign
567    = CGF.getContext().getTypeInfoInChars(baseType);
568
569  CGBuilderTy &Builder = CGF.Builder;
570
571  llvm::Value *baseSizeInChars
572    = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity());
573
574  const llvm::Type *i8p = Builder.getInt8PtrTy();
575
576  llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin");
577  llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end");
578
579  llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
580  llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
581  llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
582
583  // Make a loop over the VLA.  C99 guarantees that the VLA element
584  // count must be nonzero.
585  CGF.EmitBlock(loopBB);
586
587  llvm::PHINode *cur = Builder.CreatePHI(i8p, "vla.cur");
588  cur->reserveOperandSpace(2);
589  cur->addIncoming(begin, originBB);
590
591  // memcpy the individual element bit-pattern.
592  Builder.CreateMemCpy(cur, src, baseSizeInChars,
593                       baseSizeAndAlign.second.getQuantity(),
594                       /*volatile*/ false);
595
596  // Go to the next element.
597  llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next");
598
599  // Leave if that's the end of the VLA.
600  llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
601  Builder.CreateCondBr(done, contBB, loopBB);
602  cur->addIncoming(next, loopBB);
603
604  CGF.EmitBlock(contBB);
605}
606
607void
608CodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) {
609  // Ignore empty classes in C++.
610  if (getContext().getLangOptions().CPlusPlus) {
611    if (const RecordType *RT = Ty->getAs<RecordType>()) {
612      if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
613        return;
614    }
615  }
616
617  // Cast the dest ptr to the appropriate i8 pointer type.
618  unsigned DestAS =
619    cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace();
620  const llvm::Type *BP = Builder.getInt8PtrTy(DestAS);
621  if (DestPtr->getType() != BP)
622    DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
623
624  // Get size and alignment info for this aggregate.
625  std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
626  uint64_t Size = TypeInfo.first / 8;
627  unsigned Align = TypeInfo.second / 8;
628
629  llvm::Value *SizeVal;
630  const VariableArrayType *vla;
631
632  // Don't bother emitting a zero-byte memset.
633  if (Size == 0) {
634    // But note that getTypeInfo returns 0 for a VLA.
635    if (const VariableArrayType *vlaType =
636          dyn_cast_or_null<VariableArrayType>(
637                                          getContext().getAsArrayType(Ty))) {
638      SizeVal = GetVLASize(vlaType);
639      vla = vlaType;
640    } else {
641      return;
642    }
643  } else {
644    SizeVal = llvm::ConstantInt::get(IntPtrTy, Size);
645    vla = 0;
646  }
647
648  // If the type contains a pointer to data member we can't memset it to zero.
649  // Instead, create a null constant and copy it to the destination.
650  // TODO: there are other patterns besides zero that we can usefully memset,
651  // like -1, which happens to be the pattern used by member-pointers.
652  if (!CGM.getTypes().isZeroInitializable(Ty)) {
653    // For a VLA, emit a single element, then splat that over the VLA.
654    if (vla) Ty = getContext().getBaseElementType(vla);
655
656    llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
657
658    llvm::GlobalVariable *NullVariable =
659      new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
660                               /*isConstant=*/true,
661                               llvm::GlobalVariable::PrivateLinkage,
662                               NullConstant, llvm::Twine());
663    llvm::Value *SrcPtr =
664      Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy());
665
666    if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
667
668    // Get and call the appropriate llvm.memcpy overload.
669    Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align, false);
670    return;
671  }
672
673  // Otherwise, just memset the whole thing to zero.  This is legal
674  // because in LLVM, all default initializers (other than the ones we just
675  // handled above) are guaranteed to have a bit pattern of all zeros.
676  Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, Align, false);
677}
678
679llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) {
680  // Make sure that there is a block for the indirect goto.
681  if (IndirectBranch == 0)
682    GetIndirectGotoBlock();
683
684  llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
685
686  // Make sure the indirect branch includes all of the address-taken blocks.
687  IndirectBranch->addDestination(BB);
688  return llvm::BlockAddress::get(CurFn, BB);
689}
690
691llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
692  // If we already made the indirect branch for indirect goto, return its block.
693  if (IndirectBranch) return IndirectBranch->getParent();
694
695  CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto"));
696
697  // Create the PHI node that indirect gotos will add entries to.
698  llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest");
699
700  // Create the indirect branch instruction.
701  IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
702  return IndirectBranch->getParent();
703}
704
705llvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) {
706  llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
707
708  assert(SizeEntry && "Did not emit size for type");
709  return SizeEntry;
710}
711
712llvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) {
713  assert(Ty->isVariablyModifiedType() &&
714         "Must pass variably modified type to EmitVLASizes!");
715
716  EnsureInsertPoint();
717
718  if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) {
719    // unknown size indication requires no size computation.
720    if (!VAT->getSizeExpr())
721      return 0;
722    llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
723
724    if (!SizeEntry) {
725      const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
726
727      // Get the element size;
728      QualType ElemTy = VAT->getElementType();
729      llvm::Value *ElemSize;
730      if (ElemTy->isVariableArrayType())
731        ElemSize = EmitVLASize(ElemTy);
732      else
733        ElemSize = llvm::ConstantInt::get(SizeTy,
734            getContext().getTypeSizeInChars(ElemTy).getQuantity());
735
736      llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr());
737      NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp");
738
739      SizeEntry = Builder.CreateMul(ElemSize, NumElements);
740    }
741
742    return SizeEntry;
743  }
744
745  if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
746    EmitVLASize(AT->getElementType());
747    return 0;
748  }
749
750  if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
751    EmitVLASize(PT->getInnerType());
752    return 0;
753  }
754
755  const PointerType *PT = Ty->getAs<PointerType>();
756  assert(PT && "unknown VM type!");
757  EmitVLASize(PT->getPointeeType());
758  return 0;
759}
760
761llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) {
762  if (getContext().getBuiltinVaListType()->isArrayType())
763    return EmitScalarExpr(E);
764  return EmitLValue(E).getAddress();
765}
766
767void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
768                                              llvm::Constant *Init) {
769  assert (Init && "Invalid DeclRefExpr initializer!");
770  if (CGDebugInfo *Dbg = getDebugInfo())
771    Dbg->EmitGlobalVariable(E->getDecl(), Init);
772}
773