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