CodeGenFunction.cpp revision 413e67778d593215d2f2161a4e712c8568f1ddd0 
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 "CGDebugInfo.h"
17#include "CGException.h"
18#include "clang/Basic/TargetInfo.h"
19#include "clang/AST/APValue.h"
20#include "clang/AST/ASTContext.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/StmtCXX.h"
24#include "clang/Frontend/CodeGenOptions.h"
25#include "llvm/Target/TargetData.h"
26#include "llvm/Intrinsics.h"
27using namespace clang;
28using namespace CodeGen;
29
30CodeGenFunction::CodeGenFunction(CodeGenModule &cgm)
31  : BlockFunction(cgm, *this, Builder), CGM(cgm),
32    Target(CGM.getContext().Target),
33    Builder(cgm.getModule().getContext()),
34    NormalCleanupDest(0), EHCleanupDest(0), NextCleanupDestIndex(1),
35    ExceptionSlot(0), DebugInfo(0), IndirectBranch(0),
36    SwitchInsn(0), CaseRangeBlock(0),
37    DidCallStackSave(false), UnreachableBlock(0),
38    CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0),
39    ConditionalBranchLevel(0), TerminateLandingPad(0), TerminateHandler(0),
40    TrapBB(0) {
41
42  // Get some frequently used types.
43  LLVMPointerWidth = Target.getPointerWidth(0);
44  llvm::LLVMContext &LLVMContext = CGM.getLLVMContext();
45  IntPtrTy = llvm::IntegerType::get(LLVMContext, LLVMPointerWidth);
46  Int32Ty  = llvm::Type::getInt32Ty(LLVMContext);
47  Int64Ty  = llvm::Type::getInt64Ty(LLVMContext);
48
49  Exceptions = getContext().getLangOptions().Exceptions;
50  CatchUndefined = getContext().getLangOptions().CatchUndefined;
51  CGM.getMangleContext().startNewFunction();
52}
53
54ASTContext &CodeGenFunction::getContext() const {
55  return CGM.getContext();
56}
57
58
59llvm::Value *CodeGenFunction::GetAddrOfLocalVar(const VarDecl *VD) {
60  llvm::Value *Res = LocalDeclMap[VD];
61  assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
62  return Res;
63}
64
65llvm::Constant *
66CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) {
67  return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
68}
69
70const llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
71  return CGM.getTypes().ConvertTypeForMem(T);
72}
73
74const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
75  return CGM.getTypes().ConvertType(T);
76}
77
78bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
79  return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() ||
80    T->isMemberFunctionPointerType();
81}
82
83void CodeGenFunction::EmitReturnBlock() {
84  // For cleanliness, we try to avoid emitting the return block for
85  // simple cases.
86  llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
87
88  if (CurBB) {
89    assert(!CurBB->getTerminator() && "Unexpected terminated block.");
90
91    // We have a valid insert point, reuse it if it is empty or there are no
92    // explicit jumps to the return block.
93    if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
94      ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
95      delete ReturnBlock.getBlock();
96    } else
97      EmitBlock(ReturnBlock.getBlock());
98    return;
99  }
100
101  // Otherwise, if the return block is the target of a single direct
102  // branch then we can just put the code in that block instead. This
103  // cleans up functions which started with a unified return block.
104  if (ReturnBlock.getBlock()->hasOneUse()) {
105    llvm::BranchInst *BI =
106      dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin());
107    if (BI && BI->isUnconditional() &&
108        BI->getSuccessor(0) == ReturnBlock.getBlock()) {
109      // Reset insertion point and delete the branch.
110      Builder.SetInsertPoint(BI->getParent());
111      BI->eraseFromParent();
112      delete ReturnBlock.getBlock();
113      return;
114    }
115  }
116
117  // FIXME: We are at an unreachable point, there is no reason to emit the block
118  // unless it has uses. However, we still need a place to put the debug
119  // region.end for now.
120
121  EmitBlock(ReturnBlock.getBlock());
122}
123
124static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
125  if (!BB) return;
126  if (!BB->use_empty())
127    return CGF.CurFn->getBasicBlockList().push_back(BB);
128  delete BB;
129}
130
131void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
132  assert(BreakContinueStack.empty() &&
133         "mismatched push/pop in break/continue stack!");
134
135  // Emit function epilog (to return).
136  EmitReturnBlock();
137
138  EmitFunctionInstrumentation("__cyg_profile_func_exit");
139
140  // Emit debug descriptor for function end.
141  if (CGDebugInfo *DI = getDebugInfo()) {
142    DI->setLocation(EndLoc);
143    DI->EmitFunctionEnd(Builder);
144  }
145
146  EmitFunctionEpilog(*CurFnInfo);
147  EmitEndEHSpec(CurCodeDecl);
148
149  assert(EHStack.empty() &&
150         "did not remove all scopes from cleanup stack!");
151
152  // If someone did an indirect goto, emit the indirect goto block at the end of
153  // the function.
154  if (IndirectBranch) {
155    EmitBlock(IndirectBranch->getParent());
156    Builder.ClearInsertionPoint();
157  }
158
159  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
160  llvm::Instruction *Ptr = AllocaInsertPt;
161  AllocaInsertPt = 0;
162  Ptr->eraseFromParent();
163
164  // If someone took the address of a label but never did an indirect goto, we
165  // made a zero entry PHI node, which is illegal, zap it now.
166  if (IndirectBranch) {
167    llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
168    if (PN->getNumIncomingValues() == 0) {
169      PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
170      PN->eraseFromParent();
171    }
172  }
173
174  EmitIfUsed(*this, RethrowBlock.getBlock());
175  EmitIfUsed(*this, TerminateLandingPad);
176  EmitIfUsed(*this, TerminateHandler);
177  EmitIfUsed(*this, UnreachableBlock);
178
179  if (CGM.getCodeGenOpts().EmitDeclMetadata)
180    EmitDeclMetadata();
181}
182
183/// ShouldInstrumentFunction - Return true if the current function should be
184/// instrumented with __cyg_profile_func_* calls
185bool CodeGenFunction::ShouldInstrumentFunction() {
186  if (!CGM.getCodeGenOpts().InstrumentFunctions)
187    return false;
188  if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
189    return false;
190  return true;
191}
192
193/// EmitFunctionInstrumentation - Emit LLVM code to call the specified
194/// instrumentation function with the current function and the call site, if
195/// function instrumentation is enabled.
196void CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) {
197  if (!ShouldInstrumentFunction())
198    return;
199
200  const llvm::PointerType *PointerTy;
201  const llvm::FunctionType *FunctionTy;
202  std::vector<const llvm::Type*> ProfileFuncArgs;
203
204  // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site);
205  PointerTy = llvm::Type::getInt8PtrTy(VMContext);
206  ProfileFuncArgs.push_back(PointerTy);
207  ProfileFuncArgs.push_back(PointerTy);
208  FunctionTy = llvm::FunctionType::get(
209    llvm::Type::getVoidTy(VMContext),
210    ProfileFuncArgs, false);
211
212  llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn);
213  llvm::CallInst *CallSite = Builder.CreateCall(
214    CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0),
215    llvm::ConstantInt::get(Int32Ty, 0),
216    "callsite");
217
218  Builder.CreateCall2(F,
219                      llvm::ConstantExpr::getBitCast(CurFn, PointerTy),
220                      CallSite);
221}
222
223void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
224                                    llvm::Function *Fn,
225                                    const FunctionArgList &Args,
226                                    SourceLocation StartLoc) {
227  const Decl *D = GD.getDecl();
228
229  DidCallStackSave = false;
230  CurCodeDecl = CurFuncDecl = D;
231  FnRetTy = RetTy;
232  CurFn = Fn;
233  assert(CurFn->isDeclaration() && "Function already has body?");
234
235  // Pass inline keyword to optimizer if it appears explicitly on any
236  // declaration.
237  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
238    for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(),
239           RE = FD->redecls_end(); RI != RE; ++RI)
240      if (RI->isInlineSpecified()) {
241        Fn->addFnAttr(llvm::Attribute::InlineHint);
242        break;
243      }
244
245  llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
246
247  // Create a marker to make it easy to insert allocas into the entryblock
248  // later.  Don't create this with the builder, because we don't want it
249  // folded.
250  llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
251  AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB);
252  if (Builder.isNamePreserving())
253    AllocaInsertPt->setName("allocapt");
254
255  ReturnBlock = getJumpDestInCurrentScope("return");
256
257  Builder.SetInsertPoint(EntryBB);
258
259  QualType FnType = getContext().getFunctionType(RetTy, 0, 0, false, 0,
260                                                 false, false, 0, 0,
261                                                 /*FIXME?*/
262                                                 FunctionType::ExtInfo());
263
264  // Emit subprogram debug descriptor.
265  if (CGDebugInfo *DI = getDebugInfo()) {
266    DI->setLocation(StartLoc);
267    DI->EmitFunctionStart(GD, FnType, CurFn, Builder);
268  }
269
270  EmitFunctionInstrumentation("__cyg_profile_func_enter");
271
272  // FIXME: Leaked.
273  // CC info is ignored, hopefully?
274  CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args,
275                                              FunctionType::ExtInfo());
276
277  if (RetTy->isVoidType()) {
278    // Void type; nothing to return.
279    ReturnValue = 0;
280  } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect &&
281             hasAggregateLLVMType(CurFnInfo->getReturnType())) {
282    // Indirect aggregate return; emit returned value directly into sret slot.
283    // This reduces code size, and affects correctness in C++.
284    ReturnValue = CurFn->arg_begin();
285  } else {
286    ReturnValue = CreateIRTemp(RetTy, "retval");
287  }
288
289  EmitStartEHSpec(CurCodeDecl);
290  EmitFunctionProlog(*CurFnInfo, CurFn, Args);
291
292  if (CXXThisDecl)
293    CXXThisValue = Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this");
294  if (CXXVTTDecl)
295    CXXVTTValue = Builder.CreateLoad(LocalDeclMap[CXXVTTDecl], "vtt");
296
297  // If any of the arguments have a variably modified type, make sure to
298  // emit the type size.
299  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
300       i != e; ++i) {
301    QualType Ty = i->second;
302
303    if (Ty->isVariablyModifiedType())
304      EmitVLASize(Ty);
305  }
306}
307
308void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) {
309  const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl());
310  assert(FD->getBody());
311  EmitStmt(FD->getBody());
312}
313
314void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) {
315  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
316
317  // Check if we should generate debug info for this function.
318  if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>())
319    DebugInfo = CGM.getDebugInfo();
320
321  FunctionArgList Args;
322
323  CurGD = GD;
324  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
325    if (MD->isInstance()) {
326      // Create the implicit 'this' decl.
327      // FIXME: I'm not entirely sure I like using a fake decl just for code
328      // generation. Maybe we can come up with a better way?
329      CXXThisDecl = ImplicitParamDecl::Create(getContext(), 0,
330                                              FD->getLocation(),
331                                              &getContext().Idents.get("this"),
332                                              MD->getThisType(getContext()));
333      Args.push_back(std::make_pair(CXXThisDecl, CXXThisDecl->getType()));
334
335      // Check if we need a VTT parameter as well.
336      if (CodeGenVTables::needsVTTParameter(GD)) {
337        // FIXME: The comment about using a fake decl above applies here too.
338        QualType T = getContext().getPointerType(getContext().VoidPtrTy);
339        CXXVTTDecl =
340          ImplicitParamDecl::Create(getContext(), 0, FD->getLocation(),
341                                    &getContext().Idents.get("vtt"), T);
342        Args.push_back(std::make_pair(CXXVTTDecl, CXXVTTDecl->getType()));
343      }
344    }
345  }
346
347  if (FD->getNumParams()) {
348    const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>();
349    assert(FProto && "Function def must have prototype!");
350
351    for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
352      Args.push_back(std::make_pair(FD->getParamDecl(i),
353                                    FProto->getArgType(i)));
354  }
355
356  SourceRange BodyRange;
357  if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
358
359  // Emit the standard function prologue.
360  StartFunction(GD, FD->getResultType(), Fn, Args, BodyRange.getBegin());
361
362  // Generate the body of the function.
363  if (isa<CXXDestructorDecl>(FD))
364    EmitDestructorBody(Args);
365  else if (isa<CXXConstructorDecl>(FD))
366    EmitConstructorBody(Args);
367  else
368    EmitFunctionBody(Args);
369
370  // Emit the standard function epilogue.
371  FinishFunction(BodyRange.getEnd());
372}
373
374/// ContainsLabel - Return true if the statement contains a label in it.  If
375/// this statement is not executed normally, it not containing a label means
376/// that we can just remove the code.
377bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
378  // Null statement, not a label!
379  if (S == 0) return false;
380
381  // If this is a label, we have to emit the code, consider something like:
382  // if (0) {  ...  foo:  bar(); }  goto foo;
383  if (isa<LabelStmt>(S))
384    return true;
385
386  // If this is a case/default statement, and we haven't seen a switch, we have
387  // to emit the code.
388  if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
389    return true;
390
391  // If this is a switch statement, we want to ignore cases below it.
392  if (isa<SwitchStmt>(S))
393    IgnoreCaseStmts = true;
394
395  // Scan subexpressions for verboten labels.
396  for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end();
397       I != E; ++I)
398    if (ContainsLabel(*I, IgnoreCaseStmts))
399      return true;
400
401  return false;
402}
403
404
405/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to
406/// a constant, or if it does but contains a label, return 0.  If it constant
407/// folds to 'true' and does not contain a label, return 1, if it constant folds
408/// to 'false' and does not contain a label, return -1.
409int CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) {
410  // FIXME: Rename and handle conversion of other evaluatable things
411  // to bool.
412  Expr::EvalResult Result;
413  if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() ||
414      Result.HasSideEffects)
415    return 0;  // Not foldable, not integer or not fully evaluatable.
416
417  if (CodeGenFunction::ContainsLabel(Cond))
418    return 0;  // Contains a label.
419
420  return Result.Val.getInt().getBoolValue() ? 1 : -1;
421}
422
423
424/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
425/// statement) to the specified blocks.  Based on the condition, this might try
426/// to simplify the codegen of the conditional based on the branch.
427///
428void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
429                                           llvm::BasicBlock *TrueBlock,
430                                           llvm::BasicBlock *FalseBlock) {
431  if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond))
432    return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock);
433
434  if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
435    // Handle X && Y in a condition.
436    if (CondBOp->getOpcode() == BinaryOperator::LAnd) {
437      // If we have "1 && X", simplify the code.  "0 && X" would have constant
438      // folded if the case was simple enough.
439      if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) {
440        // br(1 && X) -> br(X).
441        return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
442      }
443
444      // If we have "X && 1", simplify the code to use an uncond branch.
445      // "X && 0" would have been constant folded to 0.
446      if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) {
447        // br(X && 1) -> br(X).
448        return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
449      }
450
451      // Emit the LHS as a conditional.  If the LHS conditional is false, we
452      // want to jump to the FalseBlock.
453      llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
454      EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock);
455      EmitBlock(LHSTrue);
456
457      // Any temporaries created here are conditional.
458      BeginConditionalBranch();
459      EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
460      EndConditionalBranch();
461
462      return;
463    } else if (CondBOp->getOpcode() == BinaryOperator::LOr) {
464      // If we have "0 || X", simplify the code.  "1 || X" would have constant
465      // folded if the case was simple enough.
466      if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) {
467        // br(0 || X) -> br(X).
468        return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
469      }
470
471      // If we have "X || 0", simplify the code to use an uncond branch.
472      // "X || 1" would have been constant folded to 1.
473      if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) {
474        // br(X || 0) -> br(X).
475        return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
476      }
477
478      // Emit the LHS as a conditional.  If the LHS conditional is true, we
479      // want to jump to the TrueBlock.
480      llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
481      EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse);
482      EmitBlock(LHSFalse);
483
484      // Any temporaries created here are conditional.
485      BeginConditionalBranch();
486      EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
487      EndConditionalBranch();
488
489      return;
490    }
491  }
492
493  if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
494    // br(!x, t, f) -> br(x, f, t)
495    if (CondUOp->getOpcode() == UnaryOperator::LNot)
496      return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock);
497  }
498
499  if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
500    // Handle ?: operator.
501
502    // Just ignore GNU ?: extension.
503    if (CondOp->getLHS()) {
504      // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
505      llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
506      llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
507      EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock);
508      EmitBlock(LHSBlock);
509      EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock);
510      EmitBlock(RHSBlock);
511      EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock);
512      return;
513    }
514  }
515
516  // Emit the code with the fully general case.
517  llvm::Value *CondV = EvaluateExprAsBool(Cond);
518  Builder.CreateCondBr(CondV, TrueBlock, FalseBlock);
519}
520
521/// ErrorUnsupported - Print out an error that codegen doesn't support the
522/// specified stmt yet.
523void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type,
524                                       bool OmitOnError) {
525  CGM.ErrorUnsupported(S, Type, OmitOnError);
526}
527
528void
529CodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) {
530  // If the type contains a pointer to data member we can't memset it to zero.
531  // Instead, create a null constant and copy it to the destination.
532  if (CGM.getTypes().ContainsPointerToDataMember(Ty)) {
533    llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
534
535    llvm::GlobalVariable *NullVariable =
536      new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
537                               /*isConstant=*/true,
538                               llvm::GlobalVariable::PrivateLinkage,
539                               NullConstant, llvm::Twine());
540    EmitAggregateCopy(DestPtr, NullVariable, Ty, /*isVolatile=*/false);
541    return;
542  }
543
544
545  // Ignore empty classes in C++.
546  if (getContext().getLangOptions().CPlusPlus) {
547    if (const RecordType *RT = Ty->getAs<RecordType>()) {
548      if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
549        return;
550    }
551  }
552
553  // Otherwise, just memset the whole thing to zero.  This is legal
554  // because in LLVM, all default initializers (other than the ones we just
555  // handled above) are guaranteed to have a bit pattern of all zeros.
556  const llvm::Type *BP = llvm::Type::getInt8PtrTy(VMContext);
557  if (DestPtr->getType() != BP)
558    DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
559
560  // Get size and alignment info for this aggregate.
561  std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
562
563  // Don't bother emitting a zero-byte memset.
564  if (TypeInfo.first == 0)
565    return;
566
567  // FIXME: Handle variable sized types.
568  Builder.CreateCall5(CGM.getMemSetFn(BP, IntPtrTy), DestPtr,
569                 llvm::Constant::getNullValue(llvm::Type::getInt8Ty(VMContext)),
570                      // TypeInfo.first describes size in bits.
571                      llvm::ConstantInt::get(IntPtrTy, TypeInfo.first/8),
572                      llvm::ConstantInt::get(Int32Ty, TypeInfo.second/8),
573                      llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext),
574                                             0));
575}
576
577llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) {
578  // Make sure that there is a block for the indirect goto.
579  if (IndirectBranch == 0)
580    GetIndirectGotoBlock();
581
582  llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
583
584  // Make sure the indirect branch includes all of the address-taken blocks.
585  IndirectBranch->addDestination(BB);
586  return llvm::BlockAddress::get(CurFn, BB);
587}
588
589llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
590  // If we already made the indirect branch for indirect goto, return its block.
591  if (IndirectBranch) return IndirectBranch->getParent();
592
593  CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto"));
594
595  const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext);
596
597  // Create the PHI node that indirect gotos will add entries to.
598  llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest");
599
600  // Create the indirect branch instruction.
601  IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
602  return IndirectBranch->getParent();
603}
604
605llvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) {
606  llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
607
608  assert(SizeEntry && "Did not emit size for type");
609  return SizeEntry;
610}
611
612llvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) {
613  assert(Ty->isVariablyModifiedType() &&
614         "Must pass variably modified type to EmitVLASizes!");
615
616  EnsureInsertPoint();
617
618  if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) {
619    llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
620
621    if (!SizeEntry) {
622      const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
623
624      // Get the element size;
625      QualType ElemTy = VAT->getElementType();
626      llvm::Value *ElemSize;
627      if (ElemTy->isVariableArrayType())
628        ElemSize = EmitVLASize(ElemTy);
629      else
630        ElemSize = llvm::ConstantInt::get(SizeTy,
631            getContext().getTypeSizeInChars(ElemTy).getQuantity());
632
633      llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr());
634      NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp");
635
636      SizeEntry = Builder.CreateMul(ElemSize, NumElements);
637    }
638
639    return SizeEntry;
640  }
641
642  if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
643    EmitVLASize(AT->getElementType());
644    return 0;
645  }
646
647  const PointerType *PT = Ty->getAs<PointerType>();
648  assert(PT && "unknown VM type!");
649  EmitVLASize(PT->getPointeeType());
650  return 0;
651}
652
653llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) {
654  if (CGM.getContext().getBuiltinVaListType()->isArrayType())
655    return EmitScalarExpr(E);
656  return EmitLValue(E).getAddress();
657}
658
659/// Pops cleanup blocks until the given savepoint is reached.
660void CodeGenFunction::PopCleanupBlocks(EHScopeStack::stable_iterator Old) {
661  assert(Old.isValid());
662
663  while (EHStack.stable_begin() != Old) {
664    EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin());
665
666    // As long as Old strictly encloses the scope's enclosing normal
667    // cleanup, we're going to emit another normal cleanup which
668    // fallthrough can propagate through.
669    bool FallThroughIsBranchThrough =
670      Old.strictlyEncloses(Scope.getEnclosingNormalCleanup());
671
672    PopCleanupBlock(FallThroughIsBranchThrough);
673  }
674}
675
676static llvm::BasicBlock *CreateNormalEntry(CodeGenFunction &CGF,
677                                           EHCleanupScope &Scope) {
678  assert(Scope.isNormalCleanup());
679  llvm::BasicBlock *Entry = Scope.getNormalBlock();
680  if (!Entry) {
681    Entry = CGF.createBasicBlock("cleanup");
682    Scope.setNormalBlock(Entry);
683  }
684  return Entry;
685}
686
687static llvm::BasicBlock *CreateEHEntry(CodeGenFunction &CGF,
688                                       EHCleanupScope &Scope) {
689  assert(Scope.isEHCleanup());
690  llvm::BasicBlock *Entry = Scope.getEHBlock();
691  if (!Entry) {
692    Entry = CGF.createBasicBlock("eh.cleanup");
693    Scope.setEHBlock(Entry);
694  }
695  return Entry;
696}
697
698/// Transitions the terminator of the given exit-block of a cleanup to
699/// be a cleanup switch.
700static llvm::SwitchInst *TransitionToCleanupSwitch(CodeGenFunction &CGF,
701                                                   llvm::BasicBlock *Block) {
702  // If it's a branch, turn it into a switch whose default
703  // destination is its original target.
704  llvm::TerminatorInst *Term = Block->getTerminator();
705  assert(Term && "can't transition block without terminator");
706
707  if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {
708    assert(Br->isUnconditional());
709    llvm::LoadInst *Load =
710      new llvm::LoadInst(CGF.getNormalCleanupDestSlot(), "cleanup.dest", Term);
711    llvm::SwitchInst *Switch =
712      llvm::SwitchInst::Create(Load, Br->getSuccessor(0), 4, Block);
713    Br->eraseFromParent();
714    return Switch;
715  } else {
716    return cast<llvm::SwitchInst>(Term);
717  }
718}
719
720/// Attempts to reduce a cleanup's entry block to a fallthrough.  This
721/// is basically llvm::MergeBlockIntoPredecessor, except
722/// simplified/optimized for the tighter constraints on cleanup blocks.
723///
724/// Returns the new block, whatever it is.
725static llvm::BasicBlock *SimplifyCleanupEntry(CodeGenFunction &CGF,
726                                              llvm::BasicBlock *Entry) {
727  llvm::BasicBlock *Pred = Entry->getSinglePredecessor();
728  if (!Pred) return Entry;
729
730  llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator());
731  if (!Br || Br->isConditional()) return Entry;
732  assert(Br->getSuccessor(0) == Entry);
733
734  // If we were previously inserting at the end of the cleanup entry
735  // block, we'll need to continue inserting at the end of the
736  // predecessor.
737  bool WasInsertBlock = CGF.Builder.GetInsertBlock() == Entry;
738  assert(!WasInsertBlock || CGF.Builder.GetInsertPoint() == Entry->end());
739
740  // Kill the branch.
741  Br->eraseFromParent();
742
743  // Merge the blocks.
744  Pred->getInstList().splice(Pred->end(), Entry->getInstList());
745
746  // Kill the entry block.
747  Entry->eraseFromParent();
748
749  if (WasInsertBlock)
750    CGF.Builder.SetInsertPoint(Pred);
751
752  return Pred;
753}
754
755static void EmitCleanup(CodeGenFunction &CGF,
756                        EHScopeStack::Cleanup *Fn,
757                        bool ForEH) {
758  if (ForEH) CGF.EHStack.pushTerminate();
759  Fn->Emit(CGF, ForEH);
760  if (ForEH) CGF.EHStack.popTerminate();
761  assert(CGF.HaveInsertPoint() && "cleanup ended with no insertion point?");
762}
763
764/// Pops a cleanup block.  If the block includes a normal cleanup, the
765/// current insertion point is threaded through the cleanup, as are
766/// any branch fixups on the cleanup.
767void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
768  assert(!EHStack.empty() && "cleanup stack is empty!");
769  assert(isa<EHCleanupScope>(*EHStack.begin()) && "top not a cleanup!");
770  EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin());
771  assert(Scope.getFixupDepth() <= EHStack.getNumBranchFixups());
772
773  // Check whether we need an EH cleanup.  This is only true if we've
774  // generated a lazy EH cleanup block.
775  bool RequiresEHCleanup = Scope.hasEHBranches();
776
777  // Check the three conditions which might require a normal cleanup:
778
779  // - whether there are branch fix-ups through this cleanup
780  unsigned FixupDepth = Scope.getFixupDepth();
781  bool HasFixups = EHStack.getNumBranchFixups() != FixupDepth;
782
783  // - whether there are branch-throughs or branch-afters
784  bool HasExistingBranches = Scope.hasBranches();
785
786  // - whether there's a fallthrough
787  llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock();
788  bool HasFallthrough = (FallthroughSource != 0);
789
790  bool RequiresNormalCleanup = false;
791  if (Scope.isNormalCleanup() &&
792      (HasFixups || HasExistingBranches || HasFallthrough)) {
793    RequiresNormalCleanup = true;
794  }
795
796  // If we don't need the cleanup at all, we're done.
797  if (!RequiresNormalCleanup && !RequiresEHCleanup) {
798    EHStack.popCleanup(); // safe because there are no fixups
799    assert(EHStack.getNumBranchFixups() == 0 ||
800           EHStack.hasNormalCleanups());
801    return;
802  }
803
804  // Copy the cleanup emission data out.  Note that SmallVector
805  // guarantees maximal alignment for its buffer regardless of its
806  // type parameter.
807  llvm::SmallVector<char, 8*sizeof(void*)> CleanupBuffer;
808  CleanupBuffer.reserve(Scope.getCleanupSize());
809  memcpy(CleanupBuffer.data(),
810         Scope.getCleanupBuffer(), Scope.getCleanupSize());
811  CleanupBuffer.set_size(Scope.getCleanupSize());
812  EHScopeStack::Cleanup *Fn =
813    reinterpret_cast<EHScopeStack::Cleanup*>(CleanupBuffer.data());
814
815  // We want to emit the EH cleanup after the normal cleanup, but go
816  // ahead and do the setup for the EH cleanup while the scope is still
817  // alive.
818  llvm::BasicBlock *EHEntry = 0;
819  llvm::SmallVector<llvm::Instruction*, 2> EHInstsToAppend;
820  if (RequiresEHCleanup) {
821    EHEntry = CreateEHEntry(*this, Scope);
822
823    // Figure out the branch-through dest if necessary.
824    llvm::BasicBlock *EHBranchThroughDest = 0;
825    if (Scope.hasEHBranchThroughs()) {
826      assert(Scope.getEnclosingEHCleanup() != EHStack.stable_end());
827      EHScope &S = *EHStack.find(Scope.getEnclosingEHCleanup());
828      EHBranchThroughDest = CreateEHEntry(*this, cast<EHCleanupScope>(S));
829    }
830
831    // If we have exactly one branch-after and no branch-throughs, we
832    // can dispatch it without a switch.
833    if (!Scope.hasEHBranchThroughs() &&
834        Scope.getNumEHBranchAfters() == 1) {
835      assert(!EHBranchThroughDest);
836
837      // TODO: remove the spurious eh.cleanup.dest stores if this edge
838      // never went through any switches.
839      llvm::BasicBlock *BranchAfterDest = Scope.getEHBranchAfterBlock(0);
840      EHInstsToAppend.push_back(llvm::BranchInst::Create(BranchAfterDest));
841
842    // Otherwise, if we have any branch-afters, we need a switch.
843    } else if (Scope.getNumEHBranchAfters()) {
844      // The default of the switch belongs to the branch-throughs if
845      // they exist.
846      llvm::BasicBlock *Default =
847        (EHBranchThroughDest ? EHBranchThroughDest : getUnreachableBlock());
848
849      const unsigned SwitchCapacity = Scope.getNumEHBranchAfters();
850
851      llvm::LoadInst *Load =
852        new llvm::LoadInst(getEHCleanupDestSlot(), "cleanup.dest");
853      llvm::SwitchInst *Switch =
854        llvm::SwitchInst::Create(Load, Default, SwitchCapacity);
855
856      EHInstsToAppend.push_back(Load);
857      EHInstsToAppend.push_back(Switch);
858
859      for (unsigned I = 0, E = Scope.getNumEHBranchAfters(); I != E; ++I)
860        Switch->addCase(Scope.getEHBranchAfterIndex(I),
861                        Scope.getEHBranchAfterBlock(I));
862
863    // Otherwise, we have only branch-throughs; jump to the next EH
864    // cleanup.
865    } else {
866      assert(EHBranchThroughDest);
867      EHInstsToAppend.push_back(llvm::BranchInst::Create(EHBranchThroughDest));
868    }
869  }
870
871  if (!RequiresNormalCleanup) {
872    EHStack.popCleanup();
873  } else {
874    // As a kindof crazy internal case, branch-through fall-throughs
875    // leave the insertion point set to the end of the last cleanup.
876    bool HasPrebranchedFallthrough =
877      (HasFallthrough && FallthroughSource->getTerminator());
878    assert(!HasPrebranchedFallthrough ||
879           FallthroughSource->getTerminator()->getSuccessor(0)
880             == Scope.getNormalBlock());
881
882    // If we have a fallthrough and no other need for the cleanup,
883    // emit it directly.
884    if (HasFallthrough && !HasPrebranchedFallthrough &&
885        !HasFixups && !HasExistingBranches) {
886
887      // Fixups can cause us to optimistically create a normal block,
888      // only to later have no real uses for it.  Just delete it in
889      // this case.
890      // TODO: we can potentially simplify all the uses after this.
891      if (Scope.getNormalBlock()) {
892        Scope.getNormalBlock()->replaceAllUsesWith(getUnreachableBlock());
893        delete Scope.getNormalBlock();
894      }
895
896      EHStack.popCleanup();
897
898      EmitCleanup(*this, Fn, /*ForEH*/ false);
899
900    // Otherwise, the best approach is to thread everything through
901    // the cleanup block and then try to clean up after ourselves.
902    } else {
903      // Force the entry block to exist.
904      llvm::BasicBlock *NormalEntry = CreateNormalEntry(*this, Scope);
905
906      // If there's a fallthrough, we need to store the cleanup
907      // destination index.  For fall-throughs this is always zero.
908      if (HasFallthrough && !HasPrebranchedFallthrough)
909        Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot());
910
911      // Emit the entry block.  This implicitly branches to it if we
912      // have fallthrough.  All the fixups and existing branches should
913      // already be branched to it.
914      EmitBlock(NormalEntry);
915
916      bool HasEnclosingCleanups =
917        (Scope.getEnclosingNormalCleanup() != EHStack.stable_end());
918
919      // Compute the branch-through dest if we need it:
920      //   - if there are branch-throughs threaded through the scope
921      //   - if fall-through is a branch-through
922      //   - if there are fixups that will be optimistically forwarded
923      //     to the enclosing cleanup
924      llvm::BasicBlock *BranchThroughDest = 0;
925      if (Scope.hasBranchThroughs() ||
926          (HasFallthrough && FallthroughIsBranchThrough) ||
927          (HasFixups && HasEnclosingCleanups)) {
928        assert(HasEnclosingCleanups);
929        EHScope &S = *EHStack.find(Scope.getEnclosingNormalCleanup());
930        BranchThroughDest = CreateNormalEntry(*this, cast<EHCleanupScope>(S));
931      }
932
933      llvm::BasicBlock *FallthroughDest = 0;
934      llvm::SmallVector<llvm::Instruction*, 2> InstsToAppend;
935
936      // If there's exactly one branch-after and no other threads,
937      // we can route it without a switch.
938      if (!Scope.hasBranchThroughs() && !HasFixups && !HasFallthrough &&
939          Scope.getNumBranchAfters() == 1) {
940        assert(!BranchThroughDest);
941
942        // TODO: clean up the possibly dead stores to the cleanup dest slot.
943        llvm::BasicBlock *BranchAfter = Scope.getBranchAfterBlock(0);
944        InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter));
945
946      // Build a switch-out if we need it:
947      //   - if there are branch-afters threaded through the scope
948      //   - if fall-through is a branch-after
949      //   - if there are fixups that have nowhere left to go and
950      //     so must be immediately resolved
951      } else if (Scope.getNumBranchAfters() ||
952                 (HasFallthrough && !FallthroughIsBranchThrough) ||
953                 (HasFixups && !HasEnclosingCleanups)) {
954
955        llvm::BasicBlock *Default =
956          (BranchThroughDest ? BranchThroughDest : getUnreachableBlock());
957
958        // TODO: base this on the number of branch-afters and fixups
959        const unsigned SwitchCapacity = 10;
960
961        llvm::LoadInst *Load =
962          new llvm::LoadInst(getNormalCleanupDestSlot(), "cleanup.dest");
963        llvm::SwitchInst *Switch =
964          llvm::SwitchInst::Create(Load, Default, SwitchCapacity);
965
966        InstsToAppend.push_back(Load);
967        InstsToAppend.push_back(Switch);
968
969        // Branch-after fallthrough.
970        if (HasFallthrough && !FallthroughIsBranchThrough) {
971          FallthroughDest = createBasicBlock("cleanup.cont");
972          Switch->addCase(Builder.getInt32(0), FallthroughDest);
973        }
974
975        for (unsigned I = 0, E = Scope.getNumBranchAfters(); I != E; ++I) {
976          Switch->addCase(Scope.getBranchAfterIndex(I),
977                          Scope.getBranchAfterBlock(I));
978        }
979
980        if (HasFixups && !HasEnclosingCleanups)
981          ResolveAllBranchFixups(Switch);
982      } else {
983        // We should always have a branch-through destination in this case.
984        assert(BranchThroughDest);
985        InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest));
986      }
987
988      // We're finally ready to pop the cleanup.
989      EHStack.popCleanup();
990      assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups);
991
992      EmitCleanup(*this, Fn, /*ForEH*/ false);
993
994      // Append the prepared cleanup prologue from above.
995      llvm::BasicBlock *NormalExit = Builder.GetInsertBlock();
996      for (unsigned I = 0, E = InstsToAppend.size(); I != E; ++I)
997        NormalExit->getInstList().push_back(InstsToAppend[I]);
998
999      // Optimistically hope that any fixups will continue falling through.
1000      for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups();
1001           I < E; ++I) {
1002        BranchFixup &Fixup = CGF.EHStack.getBranchFixup(I);
1003        if (!Fixup.Destination) continue;
1004        if (!Fixup.OptimisticBranchBlock) {
1005          new llvm::StoreInst(Builder.getInt32(Fixup.DestinationIndex),
1006                              getNormalCleanupDestSlot(),
1007                              Fixup.InitialBranch);
1008          Fixup.InitialBranch->setSuccessor(0, NormalEntry);
1009        }
1010        Fixup.OptimisticBranchBlock = NormalExit;
1011      }
1012
1013      if (FallthroughDest)
1014        EmitBlock(FallthroughDest);
1015      else if (!HasFallthrough)
1016        Builder.ClearInsertionPoint();
1017
1018      // Check whether we can merge NormalEntry into a single predecessor.
1019      // This might invalidate (non-IR) pointers to NormalEntry.
1020      llvm::BasicBlock *NewNormalEntry =
1021        SimplifyCleanupEntry(*this, NormalEntry);
1022
1023      // If it did invalidate those pointers, and NormalEntry was the same
1024      // as NormalExit, go back and patch up the fixups.
1025      if (NewNormalEntry != NormalEntry && NormalEntry == NormalExit)
1026        for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups();
1027               I < E; ++I)
1028          CGF.EHStack.getBranchFixup(I).OptimisticBranchBlock = NewNormalEntry;
1029    }
1030  }
1031
1032  assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0);
1033
1034  // Emit the EH cleanup if required.
1035  if (RequiresEHCleanup) {
1036    CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1037
1038    EmitBlock(EHEntry);
1039    EmitCleanup(*this, Fn, /*ForEH*/ true);
1040
1041    // Append the prepared cleanup prologue from above.
1042    llvm::BasicBlock *EHExit = Builder.GetInsertBlock();
1043    for (unsigned I = 0, E = EHInstsToAppend.size(); I != E; ++I)
1044      EHExit->getInstList().push_back(EHInstsToAppend[I]);
1045
1046    Builder.restoreIP(SavedIP);
1047
1048    SimplifyCleanupEntry(*this, EHEntry);
1049  }
1050}
1051
1052/// Terminate the current block by emitting a branch which might leave
1053/// the current cleanup-protected scope.  The target scope may not yet
1054/// be known, in which case this will require a fixup.
1055///
1056/// As a side-effect, this method clears the insertion point.
1057void CodeGenFunction::EmitBranchThroughCleanup(JumpDest Dest) {
1058  assert(Dest.getScopeDepth().encloses(EHStack.getInnermostNormalCleanup())
1059         && "stale jump destination");
1060
1061  if (!HaveInsertPoint())
1062    return;
1063
1064  // Create the branch.
1065  llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());
1066
1067  // If we're not in a cleanup scope, or if the destination scope is
1068  // the current normal-cleanup scope, we don't need to worry about
1069  // fixups.
1070  if (!EHStack.hasNormalCleanups() ||
1071      Dest.getScopeDepth() == EHStack.getInnermostNormalCleanup()) {
1072    Builder.ClearInsertionPoint();
1073    return;
1074  }
1075
1076  // If we can't resolve the destination cleanup scope, just add this
1077  // to the current cleanup scope as a branch fixup.
1078  if (!Dest.getScopeDepth().isValid()) {
1079    BranchFixup &Fixup = EHStack.addBranchFixup();
1080    Fixup.Destination = Dest.getBlock();
1081    Fixup.DestinationIndex = Dest.getDestIndex();
1082    Fixup.InitialBranch = BI;
1083    Fixup.OptimisticBranchBlock = 0;
1084
1085    Builder.ClearInsertionPoint();
1086    return;
1087  }
1088
1089  // Otherwise, thread through all the normal cleanups in scope.
1090
1091  // Store the index at the start.
1092  llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());
1093  new llvm::StoreInst(Index, getNormalCleanupDestSlot(), BI);
1094
1095  // Adjust BI to point to the first cleanup block.
1096  {
1097    EHCleanupScope &Scope =
1098      cast<EHCleanupScope>(*EHStack.find(EHStack.getInnermostNormalCleanup()));
1099    BI->setSuccessor(0, CreateNormalEntry(*this, Scope));
1100  }
1101
1102  // Add this destination to all the scopes involved.
1103  EHScopeStack::stable_iterator I = EHStack.getInnermostNormalCleanup();
1104  EHScopeStack::stable_iterator E = Dest.getScopeDepth();
1105  if (E.strictlyEncloses(I)) {
1106    while (true) {
1107      EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I));
1108      assert(Scope.isNormalCleanup());
1109      I = Scope.getEnclosingNormalCleanup();
1110
1111      // If this is the last cleanup we're propagating through, tell it
1112      // that there's a resolved jump moving through it.
1113      if (!E.strictlyEncloses(I)) {
1114        Scope.addBranchAfter(Index, Dest.getBlock());
1115        break;
1116      }
1117
1118      // Otherwise, tell the scope that there's a jump propoagating
1119      // through it.  If this isn't new information, all the rest of
1120      // the work has been done before.
1121      if (!Scope.addBranchThrough(Dest.getBlock()))
1122        break;
1123    }
1124  }
1125
1126  Builder.ClearInsertionPoint();
1127}
1128
1129void CodeGenFunction::EmitBranchThroughEHCleanup(UnwindDest Dest) {
1130  // We should never get invalid scope depths for an UnwindDest; that
1131  // implies that the destination wasn't set up correctly.
1132  assert(Dest.getScopeDepth().isValid() && "invalid scope depth on EH dest?");
1133
1134  if (!HaveInsertPoint())
1135    return;
1136
1137  // Create the branch.
1138  llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());
1139
1140  // If the destination is in the same EH cleanup scope as us, we
1141  // don't need to thread through anything.
1142  if (Dest.getScopeDepth() == EHStack.getInnermostEHCleanup()) {
1143    Builder.ClearInsertionPoint();
1144    return;
1145  }
1146  assert(EHStack.hasEHCleanups());
1147
1148  // Store the index at the start.
1149  llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());
1150  new llvm::StoreInst(Index, getEHCleanupDestSlot(), BI);
1151
1152  // Adjust BI to point to the first cleanup block.
1153  {
1154    EHCleanupScope &Scope =
1155      cast<EHCleanupScope>(*EHStack.find(EHStack.getInnermostEHCleanup()));
1156    BI->setSuccessor(0, CreateEHEntry(*this, Scope));
1157  }
1158
1159  // Add this destination to all the scopes involved.
1160  for (EHScopeStack::stable_iterator
1161         I = EHStack.getInnermostEHCleanup(),
1162         E = Dest.getScopeDepth(); ; ) {
1163    assert(E.strictlyEncloses(I));
1164    EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I));
1165    assert(Scope.isEHCleanup());
1166    I = Scope.getEnclosingEHCleanup();
1167
1168    // If this is the last cleanup we're propagating through, add this
1169    // as a branch-after.
1170    if (I == E) {
1171      Scope.addEHBranchAfter(Index, Dest.getBlock());
1172      break;
1173    }
1174
1175    // Otherwise, add it as a branch-through.  If this isn't new
1176    // information, all the rest of the work has been done before.
1177    if (!Scope.addEHBranchThrough(Dest.getBlock()))
1178      break;
1179  }
1180
1181  Builder.ClearInsertionPoint();
1182}
1183
1184/// All the branch fixups on the EH stack have propagated out past the
1185/// outermost normal cleanup; resolve them all by adding cases to the
1186/// given switch instruction.
1187void CodeGenFunction::ResolveAllBranchFixups(llvm::SwitchInst *Switch) {
1188  llvm::SmallPtrSet<llvm::BasicBlock*, 4> CasesAdded;
1189
1190  for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) {
1191    // Skip this fixup if its destination isn't set or if we've
1192    // already treated it.
1193    BranchFixup &Fixup = EHStack.getBranchFixup(I);
1194    if (Fixup.Destination == 0) continue;
1195    if (!CasesAdded.insert(Fixup.Destination)) continue;
1196
1197    Switch->addCase(Builder.getInt32(Fixup.DestinationIndex),
1198                    Fixup.Destination);
1199  }
1200
1201  EHStack.clearFixups();
1202}
1203
1204void CodeGenFunction::ResolveBranchFixups(llvm::BasicBlock *Block) {
1205  assert(Block && "resolving a null target block");
1206  if (!EHStack.getNumBranchFixups()) return;
1207
1208  assert(EHStack.hasNormalCleanups() &&
1209         "branch fixups exist with no normal cleanups on stack");
1210
1211  llvm::SmallPtrSet<llvm::BasicBlock*, 4> ModifiedOptimisticBlocks;
1212  bool ResolvedAny = false;
1213
1214  for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) {
1215    // Skip this fixup if its destination doesn't match.
1216    BranchFixup &Fixup = EHStack.getBranchFixup(I);
1217    if (Fixup.Destination != Block) continue;
1218
1219    Fixup.Destination = 0;
1220    ResolvedAny = true;
1221
1222    // If it doesn't have an optimistic branch block, LatestBranch is
1223    // already pointing to the right place.
1224    llvm::BasicBlock *BranchBB = Fixup.OptimisticBranchBlock;
1225    if (!BranchBB)
1226      continue;
1227
1228    // Don't process the same optimistic branch block twice.
1229    if (!ModifiedOptimisticBlocks.insert(BranchBB))
1230      continue;
1231
1232    llvm::SwitchInst *Switch = TransitionToCleanupSwitch(*this, BranchBB);
1233
1234    // Add a case to the switch.
1235    Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), Block);
1236  }
1237
1238  if (ResolvedAny)
1239    EHStack.popNullFixups();
1240}
1241
1242llvm::Value *CodeGenFunction::getNormalCleanupDestSlot() {
1243  if (!NormalCleanupDest)
1244    NormalCleanupDest =
1245      CreateTempAlloca(Builder.getInt32Ty(), "cleanup.dest.slot");
1246  return NormalCleanupDest;
1247}
1248
1249llvm::Value *CodeGenFunction::getEHCleanupDestSlot() {
1250  if (!EHCleanupDest)
1251    EHCleanupDest =
1252      CreateTempAlloca(Builder.getInt32Ty(), "eh.cleanup.dest.slot");
1253  return EHCleanupDest;
1254}
1255