xref: /llvm-project/clang/lib/CodeGen/CodeGenFunction.cpp (revision a678874975003e8ddc5fc5fdecbfd80956ef257c)
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 "clang/Basic/TargetInfo.h"
18 #include "clang/AST/APValue.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/Decl.h"
21 #include "clang/AST/DeclCXX.h"
22 #include "llvm/Support/CFG.h"
23 #include "llvm/Target/TargetData.h"
24 using namespace clang;
25 using namespace CodeGen;
26 
27 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm)
28   : BlockFunction(cgm, *this, Builder), CGM(cgm),
29     Target(CGM.getContext().Target),
30     DebugInfo(0), SwitchInsn(0), CaseRangeBlock(0), InvokeDest(0),
31     CXXThisDecl(0) {
32   LLVMIntTy = ConvertType(getContext().IntTy);
33   LLVMPointerWidth = Target.getPointerWidth(0);
34 }
35 
36 ASTContext &CodeGenFunction::getContext() const {
37   return CGM.getContext();
38 }
39 
40 
41 llvm::BasicBlock *CodeGenFunction::getBasicBlockForLabel(const LabelStmt *S) {
42   llvm::BasicBlock *&BB = LabelMap[S];
43   if (BB) return BB;
44 
45   // Create, but don't insert, the new block.
46   return BB = createBasicBlock(S->getName());
47 }
48 
49 llvm::Value *CodeGenFunction::GetAddrOfLocalVar(const VarDecl *VD) {
50   llvm::Value *Res = LocalDeclMap[VD];
51   assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
52   return Res;
53 }
54 
55 llvm::Constant *
56 CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) {
57   return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
58 }
59 
60 const llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
61   return CGM.getTypes().ConvertTypeForMem(T);
62 }
63 
64 const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
65   return CGM.getTypes().ConvertType(T);
66 }
67 
68 bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
69   // FIXME: Use positive checks instead of negative ones to be more robust in
70   // the face of extension.
71   return !T->hasPointerRepresentation() &&!T->isRealType() &&
72     !T->isVoidType() && !T->isVectorType() && !T->isFunctionType() &&
73     !T->isBlockPointerType();
74 }
75 
76 void CodeGenFunction::EmitReturnBlock() {
77   // For cleanliness, we try to avoid emitting the return block for
78   // simple cases.
79   llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
80 
81   if (CurBB) {
82     assert(!CurBB->getTerminator() && "Unexpected terminated block.");
83 
84     // We have a valid insert point, reuse it if there are no explicit
85     // jumps to the return block.
86     if (ReturnBlock->use_empty())
87       delete ReturnBlock;
88     else
89       EmitBlock(ReturnBlock);
90     return;
91   }
92 
93   // Otherwise, if the return block is the target of a single direct
94   // branch then we can just put the code in that block instead. This
95   // cleans up functions which started with a unified return block.
96   if (ReturnBlock->hasOneUse()) {
97     llvm::BranchInst *BI =
98       dyn_cast<llvm::BranchInst>(*ReturnBlock->use_begin());
99     if (BI && BI->isUnconditional() && BI->getSuccessor(0) == ReturnBlock) {
100       // Reset insertion point and delete the branch.
101       Builder.SetInsertPoint(BI->getParent());
102       BI->eraseFromParent();
103       delete ReturnBlock;
104       return;
105     }
106   }
107 
108   // FIXME: We are at an unreachable point, there is no reason to emit the block
109   // unless it has uses. However, we still need a place to put the debug
110   // region.end for now.
111 
112   EmitBlock(ReturnBlock);
113 }
114 
115 void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
116   // Finish emission of indirect switches.
117   EmitIndirectSwitches();
118 
119   assert(BreakContinueStack.empty() &&
120          "mismatched push/pop in break/continue stack!");
121   assert(BlockScopes.empty() &&
122          "did not remove all blocks from block scope map!");
123   assert(CleanupEntries.empty() &&
124          "mismatched push/pop in cleanup stack!");
125 
126   // Emit function epilog (to return).
127   EmitReturnBlock();
128 
129   // Emit debug descriptor for function end.
130   if (CGDebugInfo *DI = getDebugInfo()) {
131     DI->setLocation(EndLoc);
132     DI->EmitRegionEnd(CurFn, Builder);
133   }
134 
135   EmitFunctionEpilog(*CurFnInfo, ReturnValue);
136 
137   // Remove the AllocaInsertPt instruction, which is just a convenience for us.
138   llvm::Instruction *Ptr = AllocaInsertPt;
139   AllocaInsertPt = 0;
140   Ptr->eraseFromParent();
141 }
142 
143 void CodeGenFunction::StartFunction(const Decl *D, QualType RetTy,
144                                     llvm::Function *Fn,
145                                     const FunctionArgList &Args,
146                                     SourceLocation StartLoc) {
147   DidCallStackSave = false;
148   CurCodeDecl = CurFuncDecl = D;
149   FnRetTy = RetTy;
150   CurFn = Fn;
151   assert(CurFn->isDeclaration() && "Function already has body?");
152 
153   llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
154 
155   // Create a marker to make it easy to insert allocas into the entryblock
156   // later.  Don't create this with the builder, because we don't want it
157   // folded.
158   llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
159   AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "",
160                                          EntryBB);
161   if (Builder.isNamePreserving())
162     AllocaInsertPt->setName("allocapt");
163 
164   ReturnBlock = createBasicBlock("return");
165   ReturnValue = 0;
166   if (!RetTy->isVoidType())
167     ReturnValue = CreateTempAlloca(ConvertType(RetTy), "retval");
168 
169   Builder.SetInsertPoint(EntryBB);
170 
171   // Emit subprogram debug descriptor.
172   // FIXME: The cast here is a huge hack.
173   if (CGDebugInfo *DI = getDebugInfo()) {
174     DI->setLocation(StartLoc);
175     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
176       DI->EmitFunctionStart(CGM.getMangledName(FD), RetTy, CurFn, Builder);
177     } else {
178       // Just use LLVM function name.
179       DI->EmitFunctionStart(Fn->getName().c_str(),
180                             RetTy, CurFn, Builder);
181     }
182   }
183 
184   // FIXME: Leaked.
185   CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args);
186   EmitFunctionProlog(*CurFnInfo, CurFn, Args);
187 
188   // If any of the arguments have a variably modified type, make sure to
189   // emit the type size.
190   for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
191        i != e; ++i) {
192     QualType Ty = i->second;
193 
194     if (Ty->isVariablyModifiedType())
195       EmitVLASize(Ty);
196   }
197 }
198 
199 void CodeGenFunction::GenerateCode(const FunctionDecl *FD,
200                                    llvm::Function *Fn) {
201   // Check if we should generate debug info for this function.
202   if (CGM.getDebugInfo() && !FD->hasAttr<NodebugAttr>())
203     DebugInfo = CGM.getDebugInfo();
204 
205   FunctionArgList Args;
206 
207   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
208     if (MD->isInstance()) {
209       // Create the implicit 'this' decl.
210       // FIXME: I'm not entirely sure I like using a fake decl just for code
211       // generation. Maybe we can come up with a better way?
212       CXXThisDecl = ImplicitParamDecl::Create(getContext(), 0, SourceLocation(),
213                                               &getContext().Idents.get("this"),
214                                               MD->getThisType(getContext()));
215       Args.push_back(std::make_pair(CXXThisDecl, CXXThisDecl->getType()));
216     }
217   }
218 
219   if (FD->getNumParams()) {
220     const FunctionProtoType* FProto = FD->getType()->getAsFunctionProtoType();
221     assert(FProto && "Function def must have prototype!");
222 
223     for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
224       Args.push_back(std::make_pair(FD->getParamDecl(i),
225                                     FProto->getArgType(i)));
226   }
227 
228   // FIXME: Support CXXTryStmt here, too.
229   if (const CompoundStmt *S = FD->getCompoundBody(getContext())) {
230     StartFunction(FD, FD->getResultType(), Fn, Args, S->getLBracLoc());
231     EmitStmt(S);
232     FinishFunction(S->getRBracLoc());
233   }
234 
235   // Destroy the 'this' declaration.
236   if (CXXThisDecl)
237     CXXThisDecl->Destroy(getContext());
238 }
239 
240 /// ContainsLabel - Return true if the statement contains a label in it.  If
241 /// this statement is not executed normally, it not containing a label means
242 /// that we can just remove the code.
243 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
244   // Null statement, not a label!
245   if (S == 0) return false;
246 
247   // If this is a label, we have to emit the code, consider something like:
248   // if (0) {  ...  foo:  bar(); }  goto foo;
249   if (isa<LabelStmt>(S))
250     return true;
251 
252   // If this is a case/default statement, and we haven't seen a switch, we have
253   // to emit the code.
254   if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
255     return true;
256 
257   // If this is a switch statement, we want to ignore cases below it.
258   if (isa<SwitchStmt>(S))
259     IgnoreCaseStmts = true;
260 
261   // Scan subexpressions for verboten labels.
262   for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end();
263        I != E; ++I)
264     if (ContainsLabel(*I, IgnoreCaseStmts))
265       return true;
266 
267   return false;
268 }
269 
270 
271 /// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to
272 /// a constant, or if it does but contains a label, return 0.  If it constant
273 /// folds to 'true' and does not contain a label, return 1, if it constant folds
274 /// to 'false' and does not contain a label, return -1.
275 int CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) {
276   // FIXME: Rename and handle conversion of other evaluatable things
277   // to bool.
278   Expr::EvalResult Result;
279   if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() ||
280       Result.HasSideEffects)
281     return 0;  // Not foldable, not integer or not fully evaluatable.
282 
283   if (CodeGenFunction::ContainsLabel(Cond))
284     return 0;  // Contains a label.
285 
286   return Result.Val.getInt().getBoolValue() ? 1 : -1;
287 }
288 
289 
290 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
291 /// statement) to the specified blocks.  Based on the condition, this might try
292 /// to simplify the codegen of the conditional based on the branch.
293 ///
294 void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
295                                            llvm::BasicBlock *TrueBlock,
296                                            llvm::BasicBlock *FalseBlock) {
297   if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond))
298     return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock);
299 
300   if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
301     // Handle X && Y in a condition.
302     if (CondBOp->getOpcode() == BinaryOperator::LAnd) {
303       // If we have "1 && X", simplify the code.  "0 && X" would have constant
304       // folded if the case was simple enough.
305       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) {
306         // br(1 && X) -> br(X).
307         return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
308       }
309 
310       // If we have "X && 1", simplify the code to use an uncond branch.
311       // "X && 0" would have been constant folded to 0.
312       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) {
313         // br(X && 1) -> br(X).
314         return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
315       }
316 
317       // Emit the LHS as a conditional.  If the LHS conditional is false, we
318       // want to jump to the FalseBlock.
319       llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
320       EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock);
321       EmitBlock(LHSTrue);
322 
323       EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
324       return;
325     } else if (CondBOp->getOpcode() == BinaryOperator::LOr) {
326       // If we have "0 || X", simplify the code.  "1 || X" would have constant
327       // folded if the case was simple enough.
328       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) {
329         // br(0 || X) -> br(X).
330         return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
331       }
332 
333       // If we have "X || 0", simplify the code to use an uncond branch.
334       // "X || 1" would have been constant folded to 1.
335       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) {
336         // br(X || 0) -> br(X).
337         return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
338       }
339 
340       // Emit the LHS as a conditional.  If the LHS conditional is true, we
341       // want to jump to the TrueBlock.
342       llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
343       EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse);
344       EmitBlock(LHSFalse);
345 
346       EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
347       return;
348     }
349   }
350 
351   if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
352     // br(!x, t, f) -> br(x, f, t)
353     if (CondUOp->getOpcode() == UnaryOperator::LNot)
354       return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock);
355   }
356 
357   if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
358     // Handle ?: operator.
359 
360     // Just ignore GNU ?: extension.
361     if (CondOp->getLHS()) {
362       // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
363       llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
364       llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
365       EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock);
366       EmitBlock(LHSBlock);
367       EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock);
368       EmitBlock(RHSBlock);
369       EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock);
370       return;
371     }
372   }
373 
374   // Emit the code with the fully general case.
375   llvm::Value *CondV = EvaluateExprAsBool(Cond);
376   Builder.CreateCondBr(CondV, TrueBlock, FalseBlock);
377 }
378 
379 /// getCGRecordLayout - Return record layout info.
380 const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT,
381                                                          QualType Ty) {
382   const RecordType *RTy = Ty->getAsRecordType();
383   assert (RTy && "Unexpected type. RecordType expected here.");
384 
385   return CGT.getCGRecordLayout(RTy->getDecl());
386 }
387 
388 /// ErrorUnsupported - Print out an error that codegen doesn't support the
389 /// specified stmt yet.
390 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type,
391                                        bool OmitOnError) {
392   CGM.ErrorUnsupported(S, Type, OmitOnError);
393 }
394 
395 unsigned CodeGenFunction::GetIDForAddrOfLabel(const LabelStmt *L) {
396   // Use LabelIDs.size() as the new ID if one hasn't been assigned.
397   return LabelIDs.insert(std::make_pair(L, LabelIDs.size())).first->second;
398 }
399 
400 void CodeGenFunction::EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty) {
401   const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
402   if (DestPtr->getType() != BP)
403     DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
404 
405   // Get size and alignment info for this aggregate.
406   std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
407 
408   // Don't bother emitting a zero-byte memset.
409   if (TypeInfo.first == 0)
410     return;
411 
412   // FIXME: Handle variable sized types.
413   const llvm::Type *IntPtr = llvm::IntegerType::get(LLVMPointerWidth);
414 
415   Builder.CreateCall4(CGM.getMemSetFn(), DestPtr,
416                       llvm::ConstantInt::getNullValue(llvm::Type::Int8Ty),
417                       // TypeInfo.first describes size in bits.
418                       llvm::ConstantInt::get(IntPtr, TypeInfo.first/8),
419                       llvm::ConstantInt::get(llvm::Type::Int32Ty,
420                                              TypeInfo.second/8));
421 }
422 
423 void CodeGenFunction::EmitIndirectSwitches() {
424   llvm::BasicBlock *Default;
425 
426   if (IndirectSwitches.empty())
427     return;
428 
429   if (!LabelIDs.empty()) {
430     Default = getBasicBlockForLabel(LabelIDs.begin()->first);
431   } else {
432     // No possible targets for indirect goto, just emit an infinite
433     // loop.
434     Default = createBasicBlock("indirectgoto.loop", CurFn);
435     llvm::BranchInst::Create(Default, Default);
436   }
437 
438   for (std::vector<llvm::SwitchInst*>::iterator i = IndirectSwitches.begin(),
439          e = IndirectSwitches.end(); i != e; ++i) {
440     llvm::SwitchInst *I = *i;
441 
442     I->setSuccessor(0, Default);
443     for (std::map<const LabelStmt*,unsigned>::iterator LI = LabelIDs.begin(),
444            LE = LabelIDs.end(); LI != LE; ++LI) {
445       I->addCase(llvm::ConstantInt::get(llvm::Type::Int32Ty,
446                                         LI->second),
447                  getBasicBlockForLabel(LI->first));
448     }
449   }
450 }
451 
452 llvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT)
453 {
454   llvm::Value *&SizeEntry = VLASizeMap[VAT];
455 
456   assert(SizeEntry && "Did not emit size for type");
457   return SizeEntry;
458 }
459 
460 llvm::Value *CodeGenFunction::EmitVLASize(QualType Ty)
461 {
462   assert(Ty->isVariablyModifiedType() &&
463          "Must pass variably modified type to EmitVLASizes!");
464 
465   if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) {
466     llvm::Value *&SizeEntry = VLASizeMap[VAT];
467 
468     if (!SizeEntry) {
469       // Get the element size;
470       llvm::Value *ElemSize;
471 
472       QualType ElemTy = VAT->getElementType();
473 
474       const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
475 
476       if (ElemTy->isVariableArrayType())
477         ElemSize = EmitVLASize(ElemTy);
478       else {
479         ElemSize = llvm::ConstantInt::get(SizeTy,
480                                           getContext().getTypeSize(ElemTy) / 8);
481       }
482 
483       llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr());
484       NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp");
485 
486       SizeEntry = Builder.CreateMul(ElemSize, NumElements);
487     }
488 
489     return SizeEntry;
490   } else if (const PointerType *PT = Ty->getAsPointerType())
491     EmitVLASize(PT->getPointeeType());
492   else {
493     assert(0 && "unknown VM type!");
494   }
495 
496   return 0;
497 }
498 
499 llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) {
500   if (CGM.getContext().getBuiltinVaListType()->isArrayType()) {
501     return EmitScalarExpr(E);
502   }
503   return EmitLValue(E).getAddress();
504 }
505 
506 void CodeGenFunction::PushCleanupBlock(llvm::BasicBlock *CleanupBlock)
507 {
508   CleanupEntries.push_back(CleanupEntry(CleanupBlock));
509 }
510 
511 void CodeGenFunction::EmitCleanupBlocks(size_t OldCleanupStackSize)
512 {
513   assert(CleanupEntries.size() >= OldCleanupStackSize &&
514          "Cleanup stack mismatch!");
515 
516   while (CleanupEntries.size() > OldCleanupStackSize)
517     EmitCleanupBlock();
518 }
519 
520 CodeGenFunction::CleanupBlockInfo CodeGenFunction::PopCleanupBlock()
521 {
522   CleanupEntry &CE = CleanupEntries.back();
523 
524   llvm::BasicBlock *CleanupBlock = CE.CleanupBlock;
525 
526   std::vector<llvm::BasicBlock *> Blocks;
527   std::swap(Blocks, CE.Blocks);
528 
529   std::vector<llvm::BranchInst *> BranchFixups;
530   std::swap(BranchFixups, CE.BranchFixups);
531 
532   CleanupEntries.pop_back();
533 
534   // Check if any branch fixups pointed to the scope we just popped. If so,
535   // we can remove them.
536   for (size_t i = 0, e = BranchFixups.size(); i != e; ++i) {
537     llvm::BasicBlock *Dest = BranchFixups[i]->getSuccessor(0);
538     BlockScopeMap::iterator I = BlockScopes.find(Dest);
539 
540     if (I == BlockScopes.end())
541       continue;
542 
543     assert(I->second <= CleanupEntries.size() && "Invalid branch fixup!");
544 
545     if (I->second == CleanupEntries.size()) {
546       // We don't need to do this branch fixup.
547       BranchFixups[i] = BranchFixups.back();
548       BranchFixups.pop_back();
549       i--;
550       e--;
551       continue;
552     }
553   }
554 
555   llvm::BasicBlock *SwitchBlock = 0;
556   llvm::BasicBlock *EndBlock = 0;
557   if (!BranchFixups.empty()) {
558     SwitchBlock = createBasicBlock("cleanup.switch");
559     EndBlock = createBasicBlock("cleanup.end");
560 
561     llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
562 
563     Builder.SetInsertPoint(SwitchBlock);
564 
565     llvm::Value *DestCodePtr = CreateTempAlloca(llvm::Type::Int32Ty,
566                                                 "cleanup.dst");
567     llvm::Value *DestCode = Builder.CreateLoad(DestCodePtr, "tmp");
568 
569     // Create a switch instruction to determine where to jump next.
570     llvm::SwitchInst *SI = Builder.CreateSwitch(DestCode, EndBlock,
571                                                 BranchFixups.size());
572 
573     // Restore the current basic block (if any)
574     if (CurBB) {
575       Builder.SetInsertPoint(CurBB);
576 
577       // If we had a current basic block, we also need to emit an instruction
578       // to initialize the cleanup destination.
579       Builder.CreateStore(llvm::Constant::getNullValue(llvm::Type::Int32Ty),
580                           DestCodePtr);
581     } else
582       Builder.ClearInsertionPoint();
583 
584     for (size_t i = 0, e = BranchFixups.size(); i != e; ++i) {
585       llvm::BranchInst *BI = BranchFixups[i];
586       llvm::BasicBlock *Dest = BI->getSuccessor(0);
587 
588       // Fixup the branch instruction to point to the cleanup block.
589       BI->setSuccessor(0, CleanupBlock);
590 
591       if (CleanupEntries.empty()) {
592         llvm::ConstantInt *ID;
593 
594         // Check if we already have a destination for this block.
595         if (Dest == SI->getDefaultDest())
596           ID = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
597         else {
598           ID = SI->findCaseDest(Dest);
599           if (!ID) {
600             // No code found, get a new unique one by using the number of
601             // switch successors.
602             ID = llvm::ConstantInt::get(llvm::Type::Int32Ty,
603                                         SI->getNumSuccessors());
604             SI->addCase(ID, Dest);
605           }
606         }
607 
608         // Store the jump destination before the branch instruction.
609         new llvm::StoreInst(ID, DestCodePtr, BI);
610       } else {
611         // We need to jump through another cleanup block. Create a pad block
612         // with a branch instruction that jumps to the final destination and
613         // add it as a branch fixup to the current cleanup scope.
614 
615         // Create the pad block.
616         llvm::BasicBlock *CleanupPad = createBasicBlock("cleanup.pad", CurFn);
617 
618         // Create a unique case ID.
619         llvm::ConstantInt *ID = llvm::ConstantInt::get(llvm::Type::Int32Ty,
620                                                        SI->getNumSuccessors());
621 
622         // Store the jump destination before the branch instruction.
623         new llvm::StoreInst(ID, DestCodePtr, BI);
624 
625         // Add it as the destination.
626         SI->addCase(ID, CleanupPad);
627 
628         // Create the branch to the final destination.
629         llvm::BranchInst *BI = llvm::BranchInst::Create(Dest);
630         CleanupPad->getInstList().push_back(BI);
631 
632         // And add it as a branch fixup.
633         CleanupEntries.back().BranchFixups.push_back(BI);
634       }
635     }
636   }
637 
638   // Remove all blocks from the block scope map.
639   for (size_t i = 0, e = Blocks.size(); i != e; ++i) {
640     assert(BlockScopes.count(Blocks[i]) &&
641            "Did not find block in scope map!");
642 
643     BlockScopes.erase(Blocks[i]);
644   }
645 
646   return CleanupBlockInfo(CleanupBlock, SwitchBlock, EndBlock);
647 }
648 
649 void CodeGenFunction::EmitCleanupBlock()
650 {
651   CleanupBlockInfo Info = PopCleanupBlock();
652 
653   EmitBlock(Info.CleanupBlock);
654 
655   if (Info.SwitchBlock)
656     EmitBlock(Info.SwitchBlock);
657   if (Info.EndBlock)
658     EmitBlock(Info.EndBlock);
659 }
660 
661 void CodeGenFunction::AddBranchFixup(llvm::BranchInst *BI)
662 {
663   assert(!CleanupEntries.empty() &&
664          "Trying to add branch fixup without cleanup block!");
665 
666   // FIXME: We could be more clever here and check if there's already a branch
667   // fixup for this destination and recycle it.
668   CleanupEntries.back().BranchFixups.push_back(BI);
669 }
670 
671 void CodeGenFunction::EmitBranchThroughCleanup(llvm::BasicBlock *Dest)
672 {
673   if (!HaveInsertPoint())
674     return;
675 
676   llvm::BranchInst* BI = Builder.CreateBr(Dest);
677 
678   Builder.ClearInsertionPoint();
679 
680   // The stack is empty, no need to do any cleanup.
681   if (CleanupEntries.empty())
682     return;
683 
684   if (!Dest->getParent()) {
685     // We are trying to branch to a block that hasn't been inserted yet.
686     AddBranchFixup(BI);
687     return;
688   }
689 
690   BlockScopeMap::iterator I = BlockScopes.find(Dest);
691   if (I == BlockScopes.end()) {
692     // We are trying to jump to a block that is outside of any cleanup scope.
693     AddBranchFixup(BI);
694     return;
695   }
696 
697   assert(I->second < CleanupEntries.size() &&
698          "Trying to branch into cleanup region");
699 
700   if (I->second == CleanupEntries.size() - 1) {
701     // We have a branch to a block in the same scope.
702     return;
703   }
704 
705   AddBranchFixup(BI);
706 }
707