xref: /llvm-project/clang/lib/CodeGen/CodeGenFunction.cpp (revision d539d098a435e75e57792c167ec19e20843c2bc0)
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"
27 using namespace clang;
28 using namespace CodeGen;
29 
30 CodeGenFunction::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 
54 ASTContext &CodeGenFunction::getContext() const {
55   return CGM.getContext();
56 }
57 
58 
59 llvm::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 
65 llvm::Constant *
66 CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) {
67   return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
68 }
69 
70 const llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
71   return CGM.getTypes().ConvertTypeForMem(T);
72 }
73 
74 const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
75   return CGM.getTypes().ConvertType(T);
76 }
77 
78 bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
79   return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() ||
80     T->isMemberFunctionPointerType() || T->isObjCObjectType();
81 }
82 
83 void 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 
124 static 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 
131 void 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
185 bool 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.
196 void 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 
223 void 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 
308 void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) {
309   const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl());
310   assert(FD->getBody());
311   EmitStmt(FD->getBody());
312 }
313 
314 /// Tries to mark the given function nounwind based on the
315 /// non-existence of any throwing calls within it.  We believe this is
316 /// lightweight enough to do at -O0.
317 static void TryMarkNoThrow(llvm::Function *F) {
318   for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
319     for (llvm::BasicBlock::iterator
320            BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
321       if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI))
322         if (!Call->doesNotThrow())
323           return;
324   F->setDoesNotThrow(true);
325 }
326 
327 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) {
328   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
329 
330   // Check if we should generate debug info for this function.
331   if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>())
332     DebugInfo = CGM.getDebugInfo();
333 
334   FunctionArgList Args;
335 
336   CurGD = GD;
337   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
338     if (MD->isInstance()) {
339       // Create the implicit 'this' decl.
340       // FIXME: I'm not entirely sure I like using a fake decl just for code
341       // generation. Maybe we can come up with a better way?
342       CXXThisDecl = ImplicitParamDecl::Create(getContext(), 0,
343                                               FD->getLocation(),
344                                               &getContext().Idents.get("this"),
345                                               MD->getThisType(getContext()));
346       Args.push_back(std::make_pair(CXXThisDecl, CXXThisDecl->getType()));
347 
348       // Check if we need a VTT parameter as well.
349       if (CodeGenVTables::needsVTTParameter(GD)) {
350         // FIXME: The comment about using a fake decl above applies here too.
351         QualType T = getContext().getPointerType(getContext().VoidPtrTy);
352         CXXVTTDecl =
353           ImplicitParamDecl::Create(getContext(), 0, FD->getLocation(),
354                                     &getContext().Idents.get("vtt"), T);
355         Args.push_back(std::make_pair(CXXVTTDecl, CXXVTTDecl->getType()));
356       }
357     }
358   }
359 
360   if (FD->getNumParams()) {
361     const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>();
362     assert(FProto && "Function def must have prototype!");
363 
364     for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
365       Args.push_back(std::make_pair(FD->getParamDecl(i),
366                                     FProto->getArgType(i)));
367   }
368 
369   SourceRange BodyRange;
370   if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
371 
372   // Emit the standard function prologue.
373   StartFunction(GD, FD->getResultType(), Fn, Args, BodyRange.getBegin());
374 
375   // Generate the body of the function.
376   if (isa<CXXDestructorDecl>(FD))
377     EmitDestructorBody(Args);
378   else if (isa<CXXConstructorDecl>(FD))
379     EmitConstructorBody(Args);
380   else
381     EmitFunctionBody(Args);
382 
383   // Emit the standard function epilogue.
384   FinishFunction(BodyRange.getEnd());
385 
386   // If we haven't marked the function nothrow through other means, do
387   // a quick pass now to see if we can.
388   if (!CurFn->doesNotThrow())
389     TryMarkNoThrow(CurFn);
390 }
391 
392 /// ContainsLabel - Return true if the statement contains a label in it.  If
393 /// this statement is not executed normally, it not containing a label means
394 /// that we can just remove the code.
395 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
396   // Null statement, not a label!
397   if (S == 0) return false;
398 
399   // If this is a label, we have to emit the code, consider something like:
400   // if (0) {  ...  foo:  bar(); }  goto foo;
401   if (isa<LabelStmt>(S))
402     return true;
403 
404   // If this is a case/default statement, and we haven't seen a switch, we have
405   // to emit the code.
406   if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
407     return true;
408 
409   // If this is a switch statement, we want to ignore cases below it.
410   if (isa<SwitchStmt>(S))
411     IgnoreCaseStmts = true;
412 
413   // Scan subexpressions for verboten labels.
414   for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end();
415        I != E; ++I)
416     if (ContainsLabel(*I, IgnoreCaseStmts))
417       return true;
418 
419   return false;
420 }
421 
422 
423 /// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to
424 /// a constant, or if it does but contains a label, return 0.  If it constant
425 /// folds to 'true' and does not contain a label, return 1, if it constant folds
426 /// to 'false' and does not contain a label, return -1.
427 int CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) {
428   // FIXME: Rename and handle conversion of other evaluatable things
429   // to bool.
430   Expr::EvalResult Result;
431   if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() ||
432       Result.HasSideEffects)
433     return 0;  // Not foldable, not integer or not fully evaluatable.
434 
435   if (CodeGenFunction::ContainsLabel(Cond))
436     return 0;  // Contains a label.
437 
438   return Result.Val.getInt().getBoolValue() ? 1 : -1;
439 }
440 
441 
442 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
443 /// statement) to the specified blocks.  Based on the condition, this might try
444 /// to simplify the codegen of the conditional based on the branch.
445 ///
446 void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
447                                            llvm::BasicBlock *TrueBlock,
448                                            llvm::BasicBlock *FalseBlock) {
449   if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond))
450     return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock);
451 
452   if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
453     // Handle X && Y in a condition.
454     if (CondBOp->getOpcode() == BinaryOperator::LAnd) {
455       // If we have "1 && X", simplify the code.  "0 && X" would have constant
456       // folded if the case was simple enough.
457       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) {
458         // br(1 && X) -> br(X).
459         return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
460       }
461 
462       // If we have "X && 1", simplify the code to use an uncond branch.
463       // "X && 0" would have been constant folded to 0.
464       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) {
465         // br(X && 1) -> br(X).
466         return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
467       }
468 
469       // Emit the LHS as a conditional.  If the LHS conditional is false, we
470       // want to jump to the FalseBlock.
471       llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
472       EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock);
473       EmitBlock(LHSTrue);
474 
475       // Any temporaries created here are conditional.
476       BeginConditionalBranch();
477       EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
478       EndConditionalBranch();
479 
480       return;
481     } else if (CondBOp->getOpcode() == BinaryOperator::LOr) {
482       // If we have "0 || X", simplify the code.  "1 || X" would have constant
483       // folded if the case was simple enough.
484       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) {
485         // br(0 || X) -> br(X).
486         return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
487       }
488 
489       // If we have "X || 0", simplify the code to use an uncond branch.
490       // "X || 1" would have been constant folded to 1.
491       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) {
492         // br(X || 0) -> br(X).
493         return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
494       }
495 
496       // Emit the LHS as a conditional.  If the LHS conditional is true, we
497       // want to jump to the TrueBlock.
498       llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
499       EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse);
500       EmitBlock(LHSFalse);
501 
502       // Any temporaries created here are conditional.
503       BeginConditionalBranch();
504       EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
505       EndConditionalBranch();
506 
507       return;
508     }
509   }
510 
511   if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
512     // br(!x, t, f) -> br(x, f, t)
513     if (CondUOp->getOpcode() == UnaryOperator::LNot)
514       return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock);
515   }
516 
517   if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
518     // Handle ?: operator.
519 
520     // Just ignore GNU ?: extension.
521     if (CondOp->getLHS()) {
522       // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
523       llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
524       llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
525       EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock);
526       EmitBlock(LHSBlock);
527       EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock);
528       EmitBlock(RHSBlock);
529       EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock);
530       return;
531     }
532   }
533 
534   // Emit the code with the fully general case.
535   llvm::Value *CondV = EvaluateExprAsBool(Cond);
536   Builder.CreateCondBr(CondV, TrueBlock, FalseBlock);
537 }
538 
539 /// ErrorUnsupported - Print out an error that codegen doesn't support the
540 /// specified stmt yet.
541 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type,
542                                        bool OmitOnError) {
543   CGM.ErrorUnsupported(S, Type, OmitOnError);
544 }
545 
546 void
547 CodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) {
548   // Ignore empty classes in C++.
549   if (getContext().getLangOptions().CPlusPlus) {
550     if (const RecordType *RT = Ty->getAs<RecordType>()) {
551       if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
552         return;
553     }
554   }
555 
556   // Cast the dest ptr to the appropriate i8 pointer type.
557   unsigned DestAS =
558     cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace();
559   const llvm::Type *BP =
560     llvm::Type::getInt8PtrTy(VMContext, DestAS);
561   if (DestPtr->getType() != BP)
562     DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
563 
564   // Get size and alignment info for this aggregate.
565   std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
566   uint64_t Size = TypeInfo.first;
567   unsigned Align = TypeInfo.second;
568 
569   // Don't bother emitting a zero-byte memset.
570   if (Size == 0)
571     return;
572 
573   llvm::ConstantInt *SizeVal = llvm::ConstantInt::get(IntPtrTy, Size / 8);
574   llvm::ConstantInt *AlignVal = Builder.getInt32(Align / 8);
575 
576   // If the type contains a pointer to data member we can't memset it to zero.
577   // Instead, create a null constant and copy it to the destination.
578   if (CGM.getTypes().ContainsPointerToDataMember(Ty)) {
579     llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
580 
581     llvm::GlobalVariable *NullVariable =
582       new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
583                                /*isConstant=*/true,
584                                llvm::GlobalVariable::PrivateLinkage,
585                                NullConstant, llvm::Twine());
586     llvm::Value *SrcPtr =
587       Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy());
588 
589     // FIXME: variable-size types?
590 
591     // Get and call the appropriate llvm.memcpy overload.
592     llvm::Constant *Memcpy =
593       CGM.getMemCpyFn(DestPtr->getType(), SrcPtr->getType(), IntPtrTy);
594     Builder.CreateCall5(Memcpy, DestPtr, SrcPtr, SizeVal, AlignVal,
595                         /*volatile*/ Builder.getFalse());
596     return;
597   }
598 
599   // Otherwise, just memset the whole thing to zero.  This is legal
600   // because in LLVM, all default initializers (other than the ones we just
601   // handled above) are guaranteed to have a bit pattern of all zeros.
602 
603   // FIXME: Handle variable sized types.
604   Builder.CreateCall5(CGM.getMemSetFn(BP, IntPtrTy), DestPtr,
605                       Builder.getInt8(0),
606                       SizeVal, AlignVal, /*volatile*/ Builder.getFalse());
607 }
608 
609 llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) {
610   // Make sure that there is a block for the indirect goto.
611   if (IndirectBranch == 0)
612     GetIndirectGotoBlock();
613 
614   llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
615 
616   // Make sure the indirect branch includes all of the address-taken blocks.
617   IndirectBranch->addDestination(BB);
618   return llvm::BlockAddress::get(CurFn, BB);
619 }
620 
621 llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
622   // If we already made the indirect branch for indirect goto, return its block.
623   if (IndirectBranch) return IndirectBranch->getParent();
624 
625   CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto"));
626 
627   const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext);
628 
629   // Create the PHI node that indirect gotos will add entries to.
630   llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest");
631 
632   // Create the indirect branch instruction.
633   IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
634   return IndirectBranch->getParent();
635 }
636 
637 llvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) {
638   llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
639 
640   assert(SizeEntry && "Did not emit size for type");
641   return SizeEntry;
642 }
643 
644 llvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) {
645   assert(Ty->isVariablyModifiedType() &&
646          "Must pass variably modified type to EmitVLASizes!");
647 
648   EnsureInsertPoint();
649 
650   if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) {
651     llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
652 
653     if (!SizeEntry) {
654       const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
655 
656       // Get the element size;
657       QualType ElemTy = VAT->getElementType();
658       llvm::Value *ElemSize;
659       if (ElemTy->isVariableArrayType())
660         ElemSize = EmitVLASize(ElemTy);
661       else
662         ElemSize = llvm::ConstantInt::get(SizeTy,
663             getContext().getTypeSizeInChars(ElemTy).getQuantity());
664 
665       llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr());
666       NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp");
667 
668       SizeEntry = Builder.CreateMul(ElemSize, NumElements);
669     }
670 
671     return SizeEntry;
672   }
673 
674   if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
675     EmitVLASize(AT->getElementType());
676     return 0;
677   }
678 
679   const PointerType *PT = Ty->getAs<PointerType>();
680   assert(PT && "unknown VM type!");
681   EmitVLASize(PT->getPointeeType());
682   return 0;
683 }
684 
685 llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) {
686   if (CGM.getContext().getBuiltinVaListType()->isArrayType())
687     return EmitScalarExpr(E);
688   return EmitLValue(E).getAddress();
689 }
690 
691 /// Pops cleanup blocks until the given savepoint is reached.
692 void CodeGenFunction::PopCleanupBlocks(EHScopeStack::stable_iterator Old) {
693   assert(Old.isValid());
694 
695   while (EHStack.stable_begin() != Old) {
696     EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin());
697 
698     // As long as Old strictly encloses the scope's enclosing normal
699     // cleanup, we're going to emit another normal cleanup which
700     // fallthrough can propagate through.
701     bool FallThroughIsBranchThrough =
702       Old.strictlyEncloses(Scope.getEnclosingNormalCleanup());
703 
704     PopCleanupBlock(FallThroughIsBranchThrough);
705   }
706 }
707 
708 static llvm::BasicBlock *CreateNormalEntry(CodeGenFunction &CGF,
709                                            EHCleanupScope &Scope) {
710   assert(Scope.isNormalCleanup());
711   llvm::BasicBlock *Entry = Scope.getNormalBlock();
712   if (!Entry) {
713     Entry = CGF.createBasicBlock("cleanup");
714     Scope.setNormalBlock(Entry);
715   }
716   return Entry;
717 }
718 
719 static llvm::BasicBlock *CreateEHEntry(CodeGenFunction &CGF,
720                                        EHCleanupScope &Scope) {
721   assert(Scope.isEHCleanup());
722   llvm::BasicBlock *Entry = Scope.getEHBlock();
723   if (!Entry) {
724     Entry = CGF.createBasicBlock("eh.cleanup");
725     Scope.setEHBlock(Entry);
726   }
727   return Entry;
728 }
729 
730 /// Transitions the terminator of the given exit-block of a cleanup to
731 /// be a cleanup switch.
732 static llvm::SwitchInst *TransitionToCleanupSwitch(CodeGenFunction &CGF,
733                                                    llvm::BasicBlock *Block) {
734   // If it's a branch, turn it into a switch whose default
735   // destination is its original target.
736   llvm::TerminatorInst *Term = Block->getTerminator();
737   assert(Term && "can't transition block without terminator");
738 
739   if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {
740     assert(Br->isUnconditional());
741     llvm::LoadInst *Load =
742       new llvm::LoadInst(CGF.getNormalCleanupDestSlot(), "cleanup.dest", Term);
743     llvm::SwitchInst *Switch =
744       llvm::SwitchInst::Create(Load, Br->getSuccessor(0), 4, Block);
745     Br->eraseFromParent();
746     return Switch;
747   } else {
748     return cast<llvm::SwitchInst>(Term);
749   }
750 }
751 
752 /// Attempts to reduce a cleanup's entry block to a fallthrough.  This
753 /// is basically llvm::MergeBlockIntoPredecessor, except
754 /// simplified/optimized for the tighter constraints on cleanup blocks.
755 ///
756 /// Returns the new block, whatever it is.
757 static llvm::BasicBlock *SimplifyCleanupEntry(CodeGenFunction &CGF,
758                                               llvm::BasicBlock *Entry) {
759   llvm::BasicBlock *Pred = Entry->getSinglePredecessor();
760   if (!Pred) return Entry;
761 
762   llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator());
763   if (!Br || Br->isConditional()) return Entry;
764   assert(Br->getSuccessor(0) == Entry);
765 
766   // If we were previously inserting at the end of the cleanup entry
767   // block, we'll need to continue inserting at the end of the
768   // predecessor.
769   bool WasInsertBlock = CGF.Builder.GetInsertBlock() == Entry;
770   assert(!WasInsertBlock || CGF.Builder.GetInsertPoint() == Entry->end());
771 
772   // Kill the branch.
773   Br->eraseFromParent();
774 
775   // Merge the blocks.
776   Pred->getInstList().splice(Pred->end(), Entry->getInstList());
777 
778   // Kill the entry block.
779   Entry->eraseFromParent();
780 
781   if (WasInsertBlock)
782     CGF.Builder.SetInsertPoint(Pred);
783 
784   return Pred;
785 }
786 
787 static void EmitCleanup(CodeGenFunction &CGF,
788                         EHScopeStack::Cleanup *Fn,
789                         bool ForEH) {
790   if (ForEH) CGF.EHStack.pushTerminate();
791   Fn->Emit(CGF, ForEH);
792   if (ForEH) CGF.EHStack.popTerminate();
793   assert(CGF.HaveInsertPoint() && "cleanup ended with no insertion point?");
794 }
795 
796 /// Pops a cleanup block.  If the block includes a normal cleanup, the
797 /// current insertion point is threaded through the cleanup, as are
798 /// any branch fixups on the cleanup.
799 void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
800   assert(!EHStack.empty() && "cleanup stack is empty!");
801   assert(isa<EHCleanupScope>(*EHStack.begin()) && "top not a cleanup!");
802   EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin());
803   assert(Scope.getFixupDepth() <= EHStack.getNumBranchFixups());
804 
805   // Check whether we need an EH cleanup.  This is only true if we've
806   // generated a lazy EH cleanup block.
807   bool RequiresEHCleanup = Scope.hasEHBranches();
808 
809   // Check the three conditions which might require a normal cleanup:
810 
811   // - whether there are branch fix-ups through this cleanup
812   unsigned FixupDepth = Scope.getFixupDepth();
813   bool HasFixups = EHStack.getNumBranchFixups() != FixupDepth;
814 
815   // - whether there are branch-throughs or branch-afters
816   bool HasExistingBranches = Scope.hasBranches();
817 
818   // - whether there's a fallthrough
819   llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock();
820   bool HasFallthrough = (FallthroughSource != 0);
821 
822   bool RequiresNormalCleanup = false;
823   if (Scope.isNormalCleanup() &&
824       (HasFixups || HasExistingBranches || HasFallthrough)) {
825     RequiresNormalCleanup = true;
826   }
827 
828   // If we don't need the cleanup at all, we're done.
829   if (!RequiresNormalCleanup && !RequiresEHCleanup) {
830     EHStack.popCleanup(); // safe because there are no fixups
831     assert(EHStack.getNumBranchFixups() == 0 ||
832            EHStack.hasNormalCleanups());
833     return;
834   }
835 
836   // Copy the cleanup emission data out.  Note that SmallVector
837   // guarantees maximal alignment for its buffer regardless of its
838   // type parameter.
839   llvm::SmallVector<char, 8*sizeof(void*)> CleanupBuffer;
840   CleanupBuffer.reserve(Scope.getCleanupSize());
841   memcpy(CleanupBuffer.data(),
842          Scope.getCleanupBuffer(), Scope.getCleanupSize());
843   CleanupBuffer.set_size(Scope.getCleanupSize());
844   EHScopeStack::Cleanup *Fn =
845     reinterpret_cast<EHScopeStack::Cleanup*>(CleanupBuffer.data());
846 
847   // We want to emit the EH cleanup after the normal cleanup, but go
848   // ahead and do the setup for the EH cleanup while the scope is still
849   // alive.
850   llvm::BasicBlock *EHEntry = 0;
851   llvm::SmallVector<llvm::Instruction*, 2> EHInstsToAppend;
852   if (RequiresEHCleanup) {
853     EHEntry = CreateEHEntry(*this, Scope);
854 
855     // Figure out the branch-through dest if necessary.
856     llvm::BasicBlock *EHBranchThroughDest = 0;
857     if (Scope.hasEHBranchThroughs()) {
858       assert(Scope.getEnclosingEHCleanup() != EHStack.stable_end());
859       EHScope &S = *EHStack.find(Scope.getEnclosingEHCleanup());
860       EHBranchThroughDest = CreateEHEntry(*this, cast<EHCleanupScope>(S));
861     }
862 
863     // If we have exactly one branch-after and no branch-throughs, we
864     // can dispatch it without a switch.
865     if (!Scope.hasEHBranchThroughs() &&
866         Scope.getNumEHBranchAfters() == 1) {
867       assert(!EHBranchThroughDest);
868 
869       // TODO: remove the spurious eh.cleanup.dest stores if this edge
870       // never went through any switches.
871       llvm::BasicBlock *BranchAfterDest = Scope.getEHBranchAfterBlock(0);
872       EHInstsToAppend.push_back(llvm::BranchInst::Create(BranchAfterDest));
873 
874     // Otherwise, if we have any branch-afters, we need a switch.
875     } else if (Scope.getNumEHBranchAfters()) {
876       // The default of the switch belongs to the branch-throughs if
877       // they exist.
878       llvm::BasicBlock *Default =
879         (EHBranchThroughDest ? EHBranchThroughDest : getUnreachableBlock());
880 
881       const unsigned SwitchCapacity = Scope.getNumEHBranchAfters();
882 
883       llvm::LoadInst *Load =
884         new llvm::LoadInst(getEHCleanupDestSlot(), "cleanup.dest");
885       llvm::SwitchInst *Switch =
886         llvm::SwitchInst::Create(Load, Default, SwitchCapacity);
887 
888       EHInstsToAppend.push_back(Load);
889       EHInstsToAppend.push_back(Switch);
890 
891       for (unsigned I = 0, E = Scope.getNumEHBranchAfters(); I != E; ++I)
892         Switch->addCase(Scope.getEHBranchAfterIndex(I),
893                         Scope.getEHBranchAfterBlock(I));
894 
895     // Otherwise, we have only branch-throughs; jump to the next EH
896     // cleanup.
897     } else {
898       assert(EHBranchThroughDest);
899       EHInstsToAppend.push_back(llvm::BranchInst::Create(EHBranchThroughDest));
900     }
901   }
902 
903   if (!RequiresNormalCleanup) {
904     EHStack.popCleanup();
905   } else {
906     // As a kindof crazy internal case, branch-through fall-throughs
907     // leave the insertion point set to the end of the last cleanup.
908     bool HasPrebranchedFallthrough =
909       (HasFallthrough && FallthroughSource->getTerminator());
910     assert(!HasPrebranchedFallthrough ||
911            FallthroughSource->getTerminator()->getSuccessor(0)
912              == Scope.getNormalBlock());
913 
914     // If we have a fallthrough and no other need for the cleanup,
915     // emit it directly.
916     if (HasFallthrough && !HasPrebranchedFallthrough &&
917         !HasFixups && !HasExistingBranches) {
918 
919       // Fixups can cause us to optimistically create a normal block,
920       // only to later have no real uses for it.  Just delete it in
921       // this case.
922       // TODO: we can potentially simplify all the uses after this.
923       if (Scope.getNormalBlock()) {
924         Scope.getNormalBlock()->replaceAllUsesWith(getUnreachableBlock());
925         delete Scope.getNormalBlock();
926       }
927 
928       EHStack.popCleanup();
929 
930       EmitCleanup(*this, Fn, /*ForEH*/ false);
931 
932     // Otherwise, the best approach is to thread everything through
933     // the cleanup block and then try to clean up after ourselves.
934     } else {
935       // Force the entry block to exist.
936       llvm::BasicBlock *NormalEntry = CreateNormalEntry(*this, Scope);
937 
938       // If there's a fallthrough, we need to store the cleanup
939       // destination index.  For fall-throughs this is always zero.
940       if (HasFallthrough && !HasPrebranchedFallthrough)
941         Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot());
942 
943       // Emit the entry block.  This implicitly branches to it if we
944       // have fallthrough.  All the fixups and existing branches should
945       // already be branched to it.
946       EmitBlock(NormalEntry);
947 
948       bool HasEnclosingCleanups =
949         (Scope.getEnclosingNormalCleanup() != EHStack.stable_end());
950 
951       // Compute the branch-through dest if we need it:
952       //   - if there are branch-throughs threaded through the scope
953       //   - if fall-through is a branch-through
954       //   - if there are fixups that will be optimistically forwarded
955       //     to the enclosing cleanup
956       llvm::BasicBlock *BranchThroughDest = 0;
957       if (Scope.hasBranchThroughs() ||
958           (HasFallthrough && FallthroughIsBranchThrough) ||
959           (HasFixups && HasEnclosingCleanups)) {
960         assert(HasEnclosingCleanups);
961         EHScope &S = *EHStack.find(Scope.getEnclosingNormalCleanup());
962         BranchThroughDest = CreateNormalEntry(*this, cast<EHCleanupScope>(S));
963       }
964 
965       llvm::BasicBlock *FallthroughDest = 0;
966       llvm::SmallVector<llvm::Instruction*, 2> InstsToAppend;
967 
968       // If there's exactly one branch-after and no other threads,
969       // we can route it without a switch.
970       if (!Scope.hasBranchThroughs() && !HasFixups && !HasFallthrough &&
971           Scope.getNumBranchAfters() == 1) {
972         assert(!BranchThroughDest);
973 
974         // TODO: clean up the possibly dead stores to the cleanup dest slot.
975         llvm::BasicBlock *BranchAfter = Scope.getBranchAfterBlock(0);
976         InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter));
977 
978       // Build a switch-out if we need it:
979       //   - if there are branch-afters threaded through the scope
980       //   - if fall-through is a branch-after
981       //   - if there are fixups that have nowhere left to go and
982       //     so must be immediately resolved
983       } else if (Scope.getNumBranchAfters() ||
984                  (HasFallthrough && !FallthroughIsBranchThrough) ||
985                  (HasFixups && !HasEnclosingCleanups)) {
986 
987         llvm::BasicBlock *Default =
988           (BranchThroughDest ? BranchThroughDest : getUnreachableBlock());
989 
990         // TODO: base this on the number of branch-afters and fixups
991         const unsigned SwitchCapacity = 10;
992 
993         llvm::LoadInst *Load =
994           new llvm::LoadInst(getNormalCleanupDestSlot(), "cleanup.dest");
995         llvm::SwitchInst *Switch =
996           llvm::SwitchInst::Create(Load, Default, SwitchCapacity);
997 
998         InstsToAppend.push_back(Load);
999         InstsToAppend.push_back(Switch);
1000 
1001         // Branch-after fallthrough.
1002         if (HasFallthrough && !FallthroughIsBranchThrough) {
1003           FallthroughDest = createBasicBlock("cleanup.cont");
1004           Switch->addCase(Builder.getInt32(0), FallthroughDest);
1005         }
1006 
1007         for (unsigned I = 0, E = Scope.getNumBranchAfters(); I != E; ++I) {
1008           Switch->addCase(Scope.getBranchAfterIndex(I),
1009                           Scope.getBranchAfterBlock(I));
1010         }
1011 
1012         if (HasFixups && !HasEnclosingCleanups)
1013           ResolveAllBranchFixups(Switch);
1014       } else {
1015         // We should always have a branch-through destination in this case.
1016         assert(BranchThroughDest);
1017         InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest));
1018       }
1019 
1020       // We're finally ready to pop the cleanup.
1021       EHStack.popCleanup();
1022       assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups);
1023 
1024       EmitCleanup(*this, Fn, /*ForEH*/ false);
1025 
1026       // Append the prepared cleanup prologue from above.
1027       llvm::BasicBlock *NormalExit = Builder.GetInsertBlock();
1028       for (unsigned I = 0, E = InstsToAppend.size(); I != E; ++I)
1029         NormalExit->getInstList().push_back(InstsToAppend[I]);
1030 
1031       // Optimistically hope that any fixups will continue falling through.
1032       for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups();
1033            I < E; ++I) {
1034         BranchFixup &Fixup = CGF.EHStack.getBranchFixup(I);
1035         if (!Fixup.Destination) continue;
1036         if (!Fixup.OptimisticBranchBlock) {
1037           new llvm::StoreInst(Builder.getInt32(Fixup.DestinationIndex),
1038                               getNormalCleanupDestSlot(),
1039                               Fixup.InitialBranch);
1040           Fixup.InitialBranch->setSuccessor(0, NormalEntry);
1041         }
1042         Fixup.OptimisticBranchBlock = NormalExit;
1043       }
1044 
1045       if (FallthroughDest)
1046         EmitBlock(FallthroughDest);
1047       else if (!HasFallthrough)
1048         Builder.ClearInsertionPoint();
1049 
1050       // Check whether we can merge NormalEntry into a single predecessor.
1051       // This might invalidate (non-IR) pointers to NormalEntry.
1052       llvm::BasicBlock *NewNormalEntry =
1053         SimplifyCleanupEntry(*this, NormalEntry);
1054 
1055       // If it did invalidate those pointers, and NormalEntry was the same
1056       // as NormalExit, go back and patch up the fixups.
1057       if (NewNormalEntry != NormalEntry && NormalEntry == NormalExit)
1058         for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups();
1059                I < E; ++I)
1060           CGF.EHStack.getBranchFixup(I).OptimisticBranchBlock = NewNormalEntry;
1061     }
1062   }
1063 
1064   assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0);
1065 
1066   // Emit the EH cleanup if required.
1067   if (RequiresEHCleanup) {
1068     CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1069 
1070     EmitBlock(EHEntry);
1071     EmitCleanup(*this, Fn, /*ForEH*/ true);
1072 
1073     // Append the prepared cleanup prologue from above.
1074     llvm::BasicBlock *EHExit = Builder.GetInsertBlock();
1075     for (unsigned I = 0, E = EHInstsToAppend.size(); I != E; ++I)
1076       EHExit->getInstList().push_back(EHInstsToAppend[I]);
1077 
1078     Builder.restoreIP(SavedIP);
1079 
1080     SimplifyCleanupEntry(*this, EHEntry);
1081   }
1082 }
1083 
1084 /// Terminate the current block by emitting a branch which might leave
1085 /// the current cleanup-protected scope.  The target scope may not yet
1086 /// be known, in which case this will require a fixup.
1087 ///
1088 /// As a side-effect, this method clears the insertion point.
1089 void CodeGenFunction::EmitBranchThroughCleanup(JumpDest Dest) {
1090   assert(Dest.getScopeDepth().encloses(EHStack.getInnermostNormalCleanup())
1091          && "stale jump destination");
1092 
1093   if (!HaveInsertPoint())
1094     return;
1095 
1096   // Create the branch.
1097   llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());
1098 
1099   // If we're not in a cleanup scope, or if the destination scope is
1100   // the current normal-cleanup scope, we don't need to worry about
1101   // fixups.
1102   if (!EHStack.hasNormalCleanups() ||
1103       Dest.getScopeDepth() == EHStack.getInnermostNormalCleanup()) {
1104     Builder.ClearInsertionPoint();
1105     return;
1106   }
1107 
1108   // If we can't resolve the destination cleanup scope, just add this
1109   // to the current cleanup scope as a branch fixup.
1110   if (!Dest.getScopeDepth().isValid()) {
1111     BranchFixup &Fixup = EHStack.addBranchFixup();
1112     Fixup.Destination = Dest.getBlock();
1113     Fixup.DestinationIndex = Dest.getDestIndex();
1114     Fixup.InitialBranch = BI;
1115     Fixup.OptimisticBranchBlock = 0;
1116 
1117     Builder.ClearInsertionPoint();
1118     return;
1119   }
1120 
1121   // Otherwise, thread through all the normal cleanups in scope.
1122 
1123   // Store the index at the start.
1124   llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());
1125   new llvm::StoreInst(Index, getNormalCleanupDestSlot(), BI);
1126 
1127   // Adjust BI to point to the first cleanup block.
1128   {
1129     EHCleanupScope &Scope =
1130       cast<EHCleanupScope>(*EHStack.find(EHStack.getInnermostNormalCleanup()));
1131     BI->setSuccessor(0, CreateNormalEntry(*this, Scope));
1132   }
1133 
1134   // Add this destination to all the scopes involved.
1135   EHScopeStack::stable_iterator I = EHStack.getInnermostNormalCleanup();
1136   EHScopeStack::stable_iterator E = Dest.getScopeDepth();
1137   if (E.strictlyEncloses(I)) {
1138     while (true) {
1139       EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I));
1140       assert(Scope.isNormalCleanup());
1141       I = Scope.getEnclosingNormalCleanup();
1142 
1143       // If this is the last cleanup we're propagating through, tell it
1144       // that there's a resolved jump moving through it.
1145       if (!E.strictlyEncloses(I)) {
1146         Scope.addBranchAfter(Index, Dest.getBlock());
1147         break;
1148       }
1149 
1150       // Otherwise, tell the scope that there's a jump propoagating
1151       // through it.  If this isn't new information, all the rest of
1152       // the work has been done before.
1153       if (!Scope.addBranchThrough(Dest.getBlock()))
1154         break;
1155     }
1156   }
1157 
1158   Builder.ClearInsertionPoint();
1159 }
1160 
1161 void CodeGenFunction::EmitBranchThroughEHCleanup(UnwindDest Dest) {
1162   // We should never get invalid scope depths for an UnwindDest; that
1163   // implies that the destination wasn't set up correctly.
1164   assert(Dest.getScopeDepth().isValid() && "invalid scope depth on EH dest?");
1165 
1166   if (!HaveInsertPoint())
1167     return;
1168 
1169   // Create the branch.
1170   llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());
1171 
1172   // If the destination is in the same EH cleanup scope as us, we
1173   // don't need to thread through anything.
1174   if (Dest.getScopeDepth() == EHStack.getInnermostEHCleanup()) {
1175     Builder.ClearInsertionPoint();
1176     return;
1177   }
1178   assert(EHStack.hasEHCleanups());
1179 
1180   // Store the index at the start.
1181   llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());
1182   new llvm::StoreInst(Index, getEHCleanupDestSlot(), BI);
1183 
1184   // Adjust BI to point to the first cleanup block.
1185   {
1186     EHCleanupScope &Scope =
1187       cast<EHCleanupScope>(*EHStack.find(EHStack.getInnermostEHCleanup()));
1188     BI->setSuccessor(0, CreateEHEntry(*this, Scope));
1189   }
1190 
1191   // Add this destination to all the scopes involved.
1192   for (EHScopeStack::stable_iterator
1193          I = EHStack.getInnermostEHCleanup(),
1194          E = Dest.getScopeDepth(); ; ) {
1195     assert(E.strictlyEncloses(I));
1196     EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I));
1197     assert(Scope.isEHCleanup());
1198     I = Scope.getEnclosingEHCleanup();
1199 
1200     // If this is the last cleanup we're propagating through, add this
1201     // as a branch-after.
1202     if (I == E) {
1203       Scope.addEHBranchAfter(Index, Dest.getBlock());
1204       break;
1205     }
1206 
1207     // Otherwise, add it as a branch-through.  If this isn't new
1208     // information, all the rest of the work has been done before.
1209     if (!Scope.addEHBranchThrough(Dest.getBlock()))
1210       break;
1211   }
1212 
1213   Builder.ClearInsertionPoint();
1214 }
1215 
1216 /// All the branch fixups on the EH stack have propagated out past the
1217 /// outermost normal cleanup; resolve them all by adding cases to the
1218 /// given switch instruction.
1219 void CodeGenFunction::ResolveAllBranchFixups(llvm::SwitchInst *Switch) {
1220   llvm::SmallPtrSet<llvm::BasicBlock*, 4> CasesAdded;
1221 
1222   for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) {
1223     // Skip this fixup if its destination isn't set or if we've
1224     // already treated it.
1225     BranchFixup &Fixup = EHStack.getBranchFixup(I);
1226     if (Fixup.Destination == 0) continue;
1227     if (!CasesAdded.insert(Fixup.Destination)) continue;
1228 
1229     Switch->addCase(Builder.getInt32(Fixup.DestinationIndex),
1230                     Fixup.Destination);
1231   }
1232 
1233   EHStack.clearFixups();
1234 }
1235 
1236 void CodeGenFunction::ResolveBranchFixups(llvm::BasicBlock *Block) {
1237   assert(Block && "resolving a null target block");
1238   if (!EHStack.getNumBranchFixups()) return;
1239 
1240   assert(EHStack.hasNormalCleanups() &&
1241          "branch fixups exist with no normal cleanups on stack");
1242 
1243   llvm::SmallPtrSet<llvm::BasicBlock*, 4> ModifiedOptimisticBlocks;
1244   bool ResolvedAny = false;
1245 
1246   for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) {
1247     // Skip this fixup if its destination doesn't match.
1248     BranchFixup &Fixup = EHStack.getBranchFixup(I);
1249     if (Fixup.Destination != Block) continue;
1250 
1251     Fixup.Destination = 0;
1252     ResolvedAny = true;
1253 
1254     // If it doesn't have an optimistic branch block, LatestBranch is
1255     // already pointing to the right place.
1256     llvm::BasicBlock *BranchBB = Fixup.OptimisticBranchBlock;
1257     if (!BranchBB)
1258       continue;
1259 
1260     // Don't process the same optimistic branch block twice.
1261     if (!ModifiedOptimisticBlocks.insert(BranchBB))
1262       continue;
1263 
1264     llvm::SwitchInst *Switch = TransitionToCleanupSwitch(*this, BranchBB);
1265 
1266     // Add a case to the switch.
1267     Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), Block);
1268   }
1269 
1270   if (ResolvedAny)
1271     EHStack.popNullFixups();
1272 }
1273 
1274 llvm::Value *CodeGenFunction::getNormalCleanupDestSlot() {
1275   if (!NormalCleanupDest)
1276     NormalCleanupDest =
1277       CreateTempAlloca(Builder.getInt32Ty(), "cleanup.dest.slot");
1278   return NormalCleanupDest;
1279 }
1280 
1281 llvm::Value *CodeGenFunction::getEHCleanupDestSlot() {
1282   if (!EHCleanupDest)
1283     EHCleanupDest =
1284       CreateTempAlloca(Builder.getInt32Ty(), "eh.cleanup.dest.slot");
1285   return EHCleanupDest;
1286 }
1287 
1288 void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
1289                                               llvm::ConstantInt *Init) {
1290   assert (Init && "Invalid DeclRefExpr initializer!");
1291   if (CGDebugInfo *Dbg = getDebugInfo())
1292     Dbg->EmitGlobalVariable(E->getDecl(), Init, Builder);
1293 }
1294