1 //===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code to emit Stmt nodes as LLVM code.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenFunction.h"
15 #include "CGDebugInfo.h"
16 #include "CodeGenModule.h"
17 #include "TargetInfo.h"
18 #include "clang/AST/StmtVisitor.h"
19 #include "clang/Sema/SemaDiagnostic.h"
20 #include "clang/Basic/PrettyStackTrace.h"
21 #include "clang/Basic/TargetInfo.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/InlineAsm.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/Support/CallSite.h"
27 using namespace clang;
28 using namespace CodeGen;
30 //===----------------------------------------------------------------------===//
32 //===----------------------------------------------------------------------===//
34 void CodeGenFunction::EmitStopPoint(const Stmt *S) {
35 if (CGDebugInfo *DI = getDebugInfo()) {
37 Loc = S->getLocStart();
38 DI->EmitLocation(Builder, Loc);
44 void CodeGenFunction::EmitStmt(const Stmt *S) {
45 assert(S && "Null statement?");
47 // These statements have their own debug info handling.
48 if (EmitSimpleStmt(S))
51 // Check if we are generating unreachable code.
52 if (!HaveInsertPoint()) {
53 // If so, and the statement doesn't contain a label, then we do not need to
54 // generate actual code. This is safe because (1) the current point is
55 // unreachable, so we don't need to execute the code, and (2) we've already
56 // handled the statements which update internal data structures (like the
57 // local variable map) which could be used by subsequent statements.
58 if (!ContainsLabel(S)) {
59 // Verify that any decl statements were handled as simple, they may be in
60 // scope of subsequent reachable statements.
61 assert(!isa<DeclStmt>(*S) && "Unexpected DeclStmt!");
65 // Otherwise, make a new block to hold the code.
69 // Generate a stoppoint if we are emitting debug info.
72 switch (S->getStmtClass()) {
73 case Stmt::NoStmtClass:
74 case Stmt::CXXCatchStmtClass:
75 case Stmt::SEHExceptStmtClass:
76 case Stmt::SEHFinallyStmtClass:
77 case Stmt::MSDependentExistsStmtClass:
78 case Stmt::OMPParallelDirectiveClass:
79 llvm_unreachable("invalid statement class to emit generically");
80 case Stmt::NullStmtClass:
81 case Stmt::CompoundStmtClass:
82 case Stmt::DeclStmtClass:
83 case Stmt::LabelStmtClass:
84 case Stmt::AttributedStmtClass:
85 case Stmt::GotoStmtClass:
86 case Stmt::BreakStmtClass:
87 case Stmt::ContinueStmtClass:
88 case Stmt::DefaultStmtClass:
89 case Stmt::CaseStmtClass:
90 llvm_unreachable("should have emitted these statements as simple");
92 #define STMT(Type, Base)
93 #define ABSTRACT_STMT(Op)
94 #define EXPR(Type, Base) \
95 case Stmt::Type##Class:
96 #include "clang/AST/StmtNodes.inc"
98 // Remember the block we came in on.
99 llvm::BasicBlock *incoming = Builder.GetInsertBlock();
100 assert(incoming && "expression emission must have an insertion point");
102 EmitIgnoredExpr(cast<Expr>(S));
104 llvm::BasicBlock *outgoing = Builder.GetInsertBlock();
105 assert(outgoing && "expression emission cleared block!");
107 // The expression emitters assume (reasonably!) that the insertion
108 // point is always set. To maintain that, the call-emission code
109 // for noreturn functions has to enter a new block with no
110 // predecessors. We want to kill that block and mark the current
111 // insertion point unreachable in the common case of a call like
112 // "exit();". Since expression emission doesn't otherwise create
113 // blocks with no predecessors, we can just test for that.
114 // However, we must be careful not to do this to our incoming
115 // block, because *statement* emission does sometimes create
116 // reachable blocks which will have no predecessors until later in
117 // the function. This occurs with, e.g., labels that are not
118 // reachable by fallthrough.
119 if (incoming != outgoing && outgoing->use_empty()) {
120 outgoing->eraseFromParent();
121 Builder.ClearInsertionPoint();
126 case Stmt::IndirectGotoStmtClass:
127 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break;
129 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break;
130 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break;
131 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break;
132 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break;
134 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break;
136 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break;
137 case Stmt::GCCAsmStmtClass: // Intentional fall-through.
138 case Stmt::MSAsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break;
139 case Stmt::CapturedStmtClass: {
140 const CapturedStmt *CS = cast<CapturedStmt>(S);
141 EmitCapturedStmt(*CS, CS->getCapturedRegionKind());
144 case Stmt::ObjCAtTryStmtClass:
145 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
147 case Stmt::ObjCAtCatchStmtClass:
149 "@catch statements should be handled by EmitObjCAtTryStmt");
150 case Stmt::ObjCAtFinallyStmtClass:
152 "@finally statements should be handled by EmitObjCAtTryStmt");
153 case Stmt::ObjCAtThrowStmtClass:
154 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
156 case Stmt::ObjCAtSynchronizedStmtClass:
157 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S));
159 case Stmt::ObjCForCollectionStmtClass:
160 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
162 case Stmt::ObjCAutoreleasePoolStmtClass:
163 EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S));
166 case Stmt::CXXTryStmtClass:
167 EmitCXXTryStmt(cast<CXXTryStmt>(*S));
169 case Stmt::CXXForRangeStmtClass:
170 EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S));
172 case Stmt::SEHTryStmtClass:
173 EmitSEHTryStmt(cast<SEHTryStmt>(*S));
178 bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
179 switch (S->getStmtClass()) {
180 default: return false;
181 case Stmt::NullStmtClass: break;
182 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
183 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break;
184 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break;
185 case Stmt::AttributedStmtClass:
186 EmitAttributedStmt(cast<AttributedStmt>(*S)); break;
187 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break;
188 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break;
189 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break;
190 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break;
191 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break;
197 /// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true,
198 /// this captures the expression result of the last sub-statement and returns it
199 /// (for use by the statement expression extension).
200 llvm::Value* CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
201 AggValueSlot AggSlot) {
202 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(),
203 "LLVM IR generation of compound statement ('{}')");
205 // Keep track of the current cleanup stack depth, including debug scopes.
206 LexicalScope Scope(*this, S.getSourceRange());
208 return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot);
212 CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S,
214 AggValueSlot AggSlot) {
216 for (CompoundStmt::const_body_iterator I = S.body_begin(),
217 E = S.body_end()-GetLast; I != E; ++I)
220 llvm::Value *RetAlloca = 0;
222 // We have to special case labels here. They are statements, but when put
223 // at the end of a statement expression, they yield the value of their
224 // subexpression. Handle this by walking through all labels we encounter,
225 // emitting them before we evaluate the subexpr.
226 const Stmt *LastStmt = S.body_back();
227 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
228 EmitLabel(LS->getDecl());
229 LastStmt = LS->getSubStmt();
234 QualType ExprTy = cast<Expr>(LastStmt)->getType();
235 if (hasAggregateEvaluationKind(ExprTy)) {
236 EmitAggExpr(cast<Expr>(LastStmt), AggSlot);
238 // We can't return an RValue here because there might be cleanups at
239 // the end of the StmtExpr. Because of that, we have to emit the result
240 // here into a temporary alloca.
241 RetAlloca = CreateMemTemp(ExprTy);
242 EmitAnyExprToMem(cast<Expr>(LastStmt), RetAlloca, Qualifiers(),
251 void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) {
252 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
254 // If there is a cleanup stack, then we it isn't worth trying to
255 // simplify this block (we would need to remove it from the scope map
256 // and cleanup entry).
257 if (!EHStack.empty())
260 // Can only simplify direct branches.
261 if (!BI || !BI->isUnconditional())
264 // Can only simplify empty blocks.
265 if (BI != BB->begin())
268 BB->replaceAllUsesWith(BI->getSuccessor(0));
269 BI->eraseFromParent();
270 BB->eraseFromParent();
273 void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) {
274 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
276 // Fall out of the current block (if necessary).
279 if (IsFinished && BB->use_empty()) {
284 // Place the block after the current block, if possible, or else at
285 // the end of the function.
286 if (CurBB && CurBB->getParent())
287 CurFn->getBasicBlockList().insertAfter(CurBB, BB);
289 CurFn->getBasicBlockList().push_back(BB);
290 Builder.SetInsertPoint(BB);
293 void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) {
294 // Emit a branch from the current block to the target one if this
295 // was a real block. If this was just a fall-through block after a
296 // terminator, don't emit it.
297 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
299 if (!CurBB || CurBB->getTerminator()) {
300 // If there is no insert point or the previous block is already
301 // terminated, don't touch it.
303 // Otherwise, create a fall-through branch.
304 Builder.CreateBr(Target);
307 Builder.ClearInsertionPoint();
310 void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) {
311 bool inserted = false;
312 for (llvm::BasicBlock::use_iterator
313 i = block->use_begin(), e = block->use_end(); i != e; ++i) {
314 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(*i)) {
315 CurFn->getBasicBlockList().insertAfter(insn->getParent(), block);
322 CurFn->getBasicBlockList().push_back(block);
324 Builder.SetInsertPoint(block);
327 CodeGenFunction::JumpDest
328 CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) {
329 JumpDest &Dest = LabelMap[D];
330 if (Dest.isValid()) return Dest;
332 // Create, but don't insert, the new block.
333 Dest = JumpDest(createBasicBlock(D->getName()),
334 EHScopeStack::stable_iterator::invalid(),
335 NextCleanupDestIndex++);
339 void CodeGenFunction::EmitLabel(const LabelDecl *D) {
340 // Add this label to the current lexical scope if we're within any
341 // normal cleanups. Jumps "in" to this label --- when permitted by
342 // the language --- may need to be routed around such cleanups.
343 if (EHStack.hasNormalCleanups() && CurLexicalScope)
344 CurLexicalScope->addLabel(D);
346 JumpDest &Dest = LabelMap[D];
348 // If we didn't need a forward reference to this label, just go
349 // ahead and create a destination at the current scope.
350 if (!Dest.isValid()) {
351 Dest = getJumpDestInCurrentScope(D->getName());
353 // Otherwise, we need to give this label a target depth and remove
354 // it from the branch-fixups list.
356 assert(!Dest.getScopeDepth().isValid() && "already emitted label!");
357 Dest.setScopeDepth(EHStack.stable_begin());
358 ResolveBranchFixups(Dest.getBlock());
361 EmitBlock(Dest.getBlock());
364 /// Change the cleanup scope of the labels in this lexical scope to
365 /// match the scope of the enclosing context.
366 void CodeGenFunction::LexicalScope::rescopeLabels() {
367 assert(!Labels.empty());
368 EHScopeStack::stable_iterator innermostScope
369 = CGF.EHStack.getInnermostNormalCleanup();
371 // Change the scope depth of all the labels.
372 for (SmallVectorImpl<const LabelDecl*>::const_iterator
373 i = Labels.begin(), e = Labels.end(); i != e; ++i) {
374 assert(CGF.LabelMap.count(*i));
375 JumpDest &dest = CGF.LabelMap.find(*i)->second;
376 assert(dest.getScopeDepth().isValid());
377 assert(innermostScope.encloses(dest.getScopeDepth()));
378 dest.setScopeDepth(innermostScope);
381 // Reparent the labels if the new scope also has cleanups.
382 if (innermostScope != EHScopeStack::stable_end() && ParentScope) {
383 ParentScope->Labels.append(Labels.begin(), Labels.end());
388 void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
389 EmitLabel(S.getDecl());
390 EmitStmt(S.getSubStmt());
393 void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) {
394 EmitStmt(S.getSubStmt());
397 void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
398 // If this code is reachable then emit a stop point (if generating
399 // debug info). We have to do this ourselves because we are on the
400 // "simple" statement path.
401 if (HaveInsertPoint())
404 EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel()));
408 void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
409 if (const LabelDecl *Target = S.getConstantTarget()) {
410 EmitBranchThroughCleanup(getJumpDestForLabel(Target));
414 // Ensure that we have an i8* for our PHI node.
415 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
417 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
419 // Get the basic block for the indirect goto.
420 llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock();
422 // The first instruction in the block has to be the PHI for the switch dest,
423 // add an entry for this branch.
424 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
426 EmitBranch(IndGotoBB);
429 void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
430 // C99 6.8.4.1: The first substatement is executed if the expression compares
431 // unequal to 0. The condition must be a scalar type.
432 LexicalScope ConditionScope(*this, S.getSourceRange());
434 if (S.getConditionVariable())
435 EmitAutoVarDecl(*S.getConditionVariable());
437 // If the condition constant folds and can be elided, try to avoid emitting
438 // the condition and the dead arm of the if/else.
440 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) {
441 // Figure out which block (then or else) is executed.
442 const Stmt *Executed = S.getThen();
443 const Stmt *Skipped = S.getElse();
444 if (!CondConstant) // Condition false?
445 std::swap(Executed, Skipped);
447 // If the skipped block has no labels in it, just emit the executed block.
448 // This avoids emitting dead code and simplifies the CFG substantially.
449 if (!ContainsLabel(Skipped)) {
451 RunCleanupsScope ExecutedScope(*this);
458 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit
459 // the conditional branch.
460 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then");
461 llvm::BasicBlock *ContBlock = createBasicBlock("if.end");
462 llvm::BasicBlock *ElseBlock = ContBlock;
464 ElseBlock = createBasicBlock("if.else");
465 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock);
467 // Emit the 'then' code.
468 EmitBlock(ThenBlock);
470 RunCleanupsScope ThenScope(*this);
471 EmitStmt(S.getThen());
473 EmitBranch(ContBlock);
475 // Emit the 'else' code if present.
476 if (const Stmt *Else = S.getElse()) {
477 // There is no need to emit line number for unconditional branch.
479 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
480 EmitBlock(ElseBlock);
482 RunCleanupsScope ElseScope(*this);
485 // There is no need to emit line number for unconditional branch.
487 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
488 EmitBranch(ContBlock);
491 // Emit the continuation block for code after the if.
492 EmitBlock(ContBlock, true);
495 void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) {
496 // Emit the header for the loop, which will also become
497 // the continue target.
498 JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond");
499 EmitBlock(LoopHeader.getBlock());
501 // Create an exit block for when the condition fails, which will
502 // also become the break target.
503 JumpDest LoopExit = getJumpDestInCurrentScope("while.end");
505 // Store the blocks to use for break and continue.
506 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
508 // C++ [stmt.while]p2:
509 // When the condition of a while statement is a declaration, the
510 // scope of the variable that is declared extends from its point
511 // of declaration (3.3.2) to the end of the while statement.
513 // The object created in a condition is destroyed and created
514 // with each iteration of the loop.
515 RunCleanupsScope ConditionScope(*this);
517 if (S.getConditionVariable())
518 EmitAutoVarDecl(*S.getConditionVariable());
520 // Evaluate the conditional in the while header. C99 6.8.5.1: The
521 // evaluation of the controlling expression takes place before each
522 // execution of the loop body.
523 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
525 // while(1) is common, avoid extra exit blocks. Be sure
526 // to correctly handle break/continue though.
527 bool EmitBoolCondBranch = true;
528 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
530 EmitBoolCondBranch = false;
532 // As long as the condition is true, go to the loop body.
533 llvm::BasicBlock *LoopBody = createBasicBlock("while.body");
534 if (EmitBoolCondBranch) {
535 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
536 if (ConditionScope.requiresCleanups())
537 ExitBlock = createBasicBlock("while.exit");
539 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock);
541 if (ExitBlock != LoopExit.getBlock()) {
542 EmitBlock(ExitBlock);
543 EmitBranchThroughCleanup(LoopExit);
547 // Emit the loop body. We have to emit this in a cleanup scope
548 // because it might be a singleton DeclStmt.
550 RunCleanupsScope BodyScope(*this);
552 EmitStmt(S.getBody());
555 BreakContinueStack.pop_back();
557 // Immediately force cleanup.
558 ConditionScope.ForceCleanup();
560 // Branch to the loop header again.
561 EmitBranch(LoopHeader.getBlock());
563 // Emit the exit block.
564 EmitBlock(LoopExit.getBlock(), true);
566 // The LoopHeader typically is just a branch if we skipped emitting
567 // a branch, try to erase it.
568 if (!EmitBoolCondBranch)
569 SimplifyForwardingBlocks(LoopHeader.getBlock());
572 void CodeGenFunction::EmitDoStmt(const DoStmt &S) {
573 JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
574 JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
576 // Store the blocks to use for break and continue.
577 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
579 // Emit the body of the loop.
580 llvm::BasicBlock *LoopBody = createBasicBlock("do.body");
583 RunCleanupsScope BodyScope(*this);
584 EmitStmt(S.getBody());
587 BreakContinueStack.pop_back();
589 EmitBlock(LoopCond.getBlock());
591 // C99 6.8.5.2: "The evaluation of the controlling expression takes place
592 // after each execution of the loop body."
594 // Evaluate the conditional in the while header.
595 // C99 6.8.5p2/p4: The first substatement is executed if the expression
596 // compares unequal to 0. The condition must be a scalar type.
597 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
599 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure
600 // to correctly handle break/continue though.
601 bool EmitBoolCondBranch = true;
602 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
604 EmitBoolCondBranch = false;
606 // As long as the condition is true, iterate the loop.
607 if (EmitBoolCondBranch)
608 Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock());
610 // Emit the exit block.
611 EmitBlock(LoopExit.getBlock());
613 // The DoCond block typically is just a branch if we skipped
614 // emitting a branch, try to erase it.
615 if (!EmitBoolCondBranch)
616 SimplifyForwardingBlocks(LoopCond.getBlock());
619 void CodeGenFunction::EmitForStmt(const ForStmt &S) {
620 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
622 RunCleanupsScope ForScope(*this);
624 CGDebugInfo *DI = getDebugInfo();
626 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
628 // Evaluate the first part before the loop.
630 EmitStmt(S.getInit());
632 // Start the loop with a block that tests the condition.
633 // If there's an increment, the continue scope will be overwritten
635 JumpDest Continue = getJumpDestInCurrentScope("for.cond");
636 llvm::BasicBlock *CondBlock = Continue.getBlock();
637 EmitBlock(CondBlock);
639 // Create a cleanup scope for the condition variable cleanups.
640 RunCleanupsScope ConditionScope(*this);
643 // If the for statement has a condition scope, emit the local variable
645 if (S.getConditionVariable()) {
646 EmitAutoVarDecl(*S.getConditionVariable());
649 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
650 // If there are any cleanups between here and the loop-exit scope,
651 // create a block to stage a loop exit along.
652 if (ForScope.requiresCleanups())
653 ExitBlock = createBasicBlock("for.cond.cleanup");
655 // As long as the condition is true, iterate the loop.
656 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
658 // C99 6.8.5p2/p4: The first substatement is executed if the expression
659 // compares unequal to 0. The condition must be a scalar type.
660 EmitBranchOnBoolExpr(S.getCond(), ForBody, ExitBlock);
662 if (ExitBlock != LoopExit.getBlock()) {
663 EmitBlock(ExitBlock);
664 EmitBranchThroughCleanup(LoopExit);
669 // Treat it as a non-zero constant. Don't even create a new block for the
670 // body, just fall into it.
673 // If the for loop doesn't have an increment we can just use the
674 // condition as the continue block. Otherwise we'll need to create
675 // a block for it (in the current scope, i.e. in the scope of the
676 // condition), and that we will become our continue block.
678 Continue = getJumpDestInCurrentScope("for.inc");
680 // Store the blocks to use for break and continue.
681 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
684 // Create a separate cleanup scope for the body, in case it is not
685 // a compound statement.
686 RunCleanupsScope BodyScope(*this);
687 EmitStmt(S.getBody());
690 // If there is an increment, emit it next.
692 EmitBlock(Continue.getBlock());
693 EmitStmt(S.getInc());
696 BreakContinueStack.pop_back();
698 ConditionScope.ForceCleanup();
699 EmitBranch(CondBlock);
701 ForScope.ForceCleanup();
704 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
706 // Emit the fall-through block.
707 EmitBlock(LoopExit.getBlock(), true);
710 void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) {
711 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
713 RunCleanupsScope ForScope(*this);
715 CGDebugInfo *DI = getDebugInfo();
717 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
719 // Evaluate the first pieces before the loop.
720 EmitStmt(S.getRangeStmt());
721 EmitStmt(S.getBeginEndStmt());
723 // Start the loop with a block that tests the condition.
724 // If there's an increment, the continue scope will be overwritten
726 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
727 EmitBlock(CondBlock);
729 // If there are any cleanups between here and the loop-exit scope,
730 // create a block to stage a loop exit along.
731 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
732 if (ForScope.requiresCleanups())
733 ExitBlock = createBasicBlock("for.cond.cleanup");
735 // The loop body, consisting of the specified body and the loop variable.
736 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
738 // The body is executed if the expression, contextually converted
740 EmitBranchOnBoolExpr(S.getCond(), ForBody, ExitBlock);
742 if (ExitBlock != LoopExit.getBlock()) {
743 EmitBlock(ExitBlock);
744 EmitBranchThroughCleanup(LoopExit);
749 // Create a block for the increment. In case of a 'continue', we jump there.
750 JumpDest Continue = getJumpDestInCurrentScope("for.inc");
752 // Store the blocks to use for break and continue.
753 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
756 // Create a separate cleanup scope for the loop variable and body.
757 RunCleanupsScope BodyScope(*this);
758 EmitStmt(S.getLoopVarStmt());
759 EmitStmt(S.getBody());
762 // If there is an increment, emit it next.
763 EmitBlock(Continue.getBlock());
764 EmitStmt(S.getInc());
766 BreakContinueStack.pop_back();
768 EmitBranch(CondBlock);
770 ForScope.ForceCleanup();
773 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
775 // Emit the fall-through block.
776 EmitBlock(LoopExit.getBlock(), true);
779 void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) {
781 Builder.CreateStore(RV.getScalarVal(), ReturnValue);
782 } else if (RV.isAggregate()) {
783 EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty);
785 EmitStoreOfComplex(RV.getComplexVal(),
786 MakeNaturalAlignAddrLValue(ReturnValue, Ty),
789 EmitBranchThroughCleanup(ReturnBlock);
792 /// EmitReturnStmt - Note that due to GCC extensions, this can have an operand
793 /// if the function returns void, or may be missing one if the function returns
794 /// non-void. Fun stuff :).
795 void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
796 // Emit the result value, even if unused, to evalute the side effects.
797 const Expr *RV = S.getRetValue();
799 // Treat block literals in a return expression as if they appeared
800 // in their own scope. This permits a small, easily-implemented
801 // exception to our over-conservative rules about not jumping to
802 // statements following block literals with non-trivial cleanups.
803 RunCleanupsScope cleanupScope(*this);
804 if (const ExprWithCleanups *cleanups =
805 dyn_cast_or_null<ExprWithCleanups>(RV)) {
806 enterFullExpression(cleanups);
807 RV = cleanups->getSubExpr();
810 // FIXME: Clean this up by using an LValue for ReturnTemp,
811 // EmitStoreThroughLValue, and EmitAnyExpr.
812 if (S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) {
813 // Apply the named return value optimization for this return statement,
814 // which means doing nothing: the appropriate result has already been
815 // constructed into the NRVO variable.
817 // If there is an NRVO flag for this variable, set it to 1 into indicate
818 // that the cleanup code should not destroy the variable.
819 if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()])
820 Builder.CreateStore(Builder.getTrue(), NRVOFlag);
821 } else if (!ReturnValue) {
822 // Make sure not to return anything, but evaluate the expression
826 } else if (RV == 0) {
827 // Do nothing (return value is left uninitialized)
828 } else if (FnRetTy->isReferenceType()) {
829 // If this function returns a reference, take the address of the expression
830 // rather than the value.
831 RValue Result = EmitReferenceBindingToExpr(RV);
832 Builder.CreateStore(Result.getScalarVal(), ReturnValue);
834 switch (getEvaluationKind(RV->getType())) {
836 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue);
839 EmitComplexExprIntoLValue(RV,
840 MakeNaturalAlignAddrLValue(ReturnValue, RV->getType()),
843 case TEK_Aggregate: {
844 CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType());
845 EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment,
847 AggValueSlot::IsDestructed,
848 AggValueSlot::DoesNotNeedGCBarriers,
849 AggValueSlot::IsNotAliased));
856 if (RV == 0 || RV->isEvaluatable(getContext()))
857 ++NumSimpleReturnExprs;
859 cleanupScope.ForceCleanup();
860 EmitBranchThroughCleanup(ReturnBlock);
863 void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
864 // As long as debug info is modeled with instructions, we have to ensure we
865 // have a place to insert here and write the stop point here.
866 if (HaveInsertPoint())
869 for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end();
874 void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) {
875 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
877 // If this code is reachable then emit a stop point (if generating
878 // debug info). We have to do this ourselves because we are on the
879 // "simple" statement path.
880 if (HaveInsertPoint())
883 JumpDest Block = BreakContinueStack.back().BreakBlock;
884 EmitBranchThroughCleanup(Block);
887 void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) {
888 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
890 // If this code is reachable then emit a stop point (if generating
891 // debug info). We have to do this ourselves because we are on the
892 // "simple" statement path.
893 if (HaveInsertPoint())
896 JumpDest Block = BreakContinueStack.back().ContinueBlock;
897 EmitBranchThroughCleanup(Block);
900 /// EmitCaseStmtRange - If case statement range is not too big then
901 /// add multiple cases to switch instruction, one for each value within
902 /// the range. If range is too big then emit "if" condition check.
903 void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
904 assert(S.getRHS() && "Expected RHS value in CaseStmt");
906 llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext());
907 llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext());
909 // Emit the code for this case. We do this first to make sure it is
910 // properly chained from our predecessor before generating the
911 // switch machinery to enter this block.
912 EmitBlock(createBasicBlock("sw.bb"));
913 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
914 EmitStmt(S.getSubStmt());
916 // If range is empty, do nothing.
917 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
920 llvm::APInt Range = RHS - LHS;
921 // FIXME: parameters such as this should not be hardcoded.
922 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
923 // Range is small enough to add multiple switch instruction cases.
924 for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) {
925 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest);
931 // The range is too big. Emit "if" condition into a new block,
932 // making sure to save and restore the current insertion point.
933 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
935 // Push this test onto the chain of range checks (which terminates
936 // in the default basic block). The switch's default will be changed
937 // to the top of this chain after switch emission is complete.
938 llvm::BasicBlock *FalseDest = CaseRangeBlock;
939 CaseRangeBlock = createBasicBlock("sw.caserange");
941 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
942 Builder.SetInsertPoint(CaseRangeBlock);
946 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
948 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
949 Builder.CreateCondBr(Cond, CaseDest, FalseDest);
951 // Restore the appropriate insertion point.
953 Builder.SetInsertPoint(RestoreBB);
955 Builder.ClearInsertionPoint();
958 void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) {
959 // If there is no enclosing switch instance that we're aware of, then this
960 // case statement and its block can be elided. This situation only happens
961 // when we've constant-folded the switch, are emitting the constant case,
962 // and part of the constant case includes another case statement. For
963 // instance: switch (4) { case 4: do { case 5: } while (1); }
965 EmitStmt(S.getSubStmt());
969 // Handle case ranges.
971 EmitCaseStmtRange(S);
975 llvm::ConstantInt *CaseVal =
976 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
978 // If the body of the case is just a 'break', and if there was no fallthrough,
979 // try to not emit an empty block.
980 if ((CGM.getCodeGenOpts().OptimizationLevel > 0) &&
981 isa<BreakStmt>(S.getSubStmt())) {
982 JumpDest Block = BreakContinueStack.back().BreakBlock;
984 // Only do this optimization if there are no cleanups that need emitting.
985 if (isObviouslyBranchWithoutCleanups(Block)) {
986 SwitchInsn->addCase(CaseVal, Block.getBlock());
988 // If there was a fallthrough into this case, make sure to redirect it to
989 // the end of the switch as well.
990 if (Builder.GetInsertBlock()) {
991 Builder.CreateBr(Block.getBlock());
992 Builder.ClearInsertionPoint();
998 EmitBlock(createBasicBlock("sw.bb"));
999 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
1000 SwitchInsn->addCase(CaseVal, CaseDest);
1002 // Recursively emitting the statement is acceptable, but is not wonderful for
1003 // code where we have many case statements nested together, i.e.:
1007 // Handling this recursively will create a new block for each case statement
1008 // that falls through to the next case which is IR intensive. It also causes
1009 // deep recursion which can run into stack depth limitations. Handle
1010 // sequential non-range case statements specially.
1011 const CaseStmt *CurCase = &S;
1012 const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt());
1014 // Otherwise, iteratively add consecutive cases to this switch stmt.
1015 while (NextCase && NextCase->getRHS() == 0) {
1017 llvm::ConstantInt *CaseVal =
1018 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
1019 SwitchInsn->addCase(CaseVal, CaseDest);
1020 NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt());
1023 // Normal default recursion for non-cases.
1024 EmitStmt(CurCase->getSubStmt());
1027 void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {
1028 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
1029 assert(DefaultBlock->empty() &&
1030 "EmitDefaultStmt: Default block already defined?");
1031 EmitBlock(DefaultBlock);
1032 EmitStmt(S.getSubStmt());
1035 /// CollectStatementsForCase - Given the body of a 'switch' statement and a
1036 /// constant value that is being switched on, see if we can dead code eliminate
1037 /// the body of the switch to a simple series of statements to emit. Basically,
1038 /// on a switch (5) we want to find these statements:
1040 /// printf(...); <--
1044 /// and add them to the ResultStmts vector. If it is unsafe to do this
1045 /// transformation (for example, one of the elided statements contains a label
1046 /// that might be jumped to), return CSFC_Failure. If we handled it and 'S'
1047 /// should include statements after it (e.g. the printf() line is a substmt of
1048 /// the case) then return CSFC_FallThrough. If we handled it and found a break
1049 /// statement, then return CSFC_Success.
1051 /// If Case is non-null, then we are looking for the specified case, checking
1052 /// that nothing we jump over contains labels. If Case is null, then we found
1053 /// the case and are looking for the break.
1055 /// If the recursive walk actually finds our Case, then we set FoundCase to
1058 enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success };
1059 static CSFC_Result CollectStatementsForCase(const Stmt *S,
1060 const SwitchCase *Case,
1062 SmallVectorImpl<const Stmt*> &ResultStmts) {
1063 // If this is a null statement, just succeed.
1065 return Case ? CSFC_Success : CSFC_FallThrough;
1067 // If this is the switchcase (case 4: or default) that we're looking for, then
1068 // we're in business. Just add the substatement.
1069 if (const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1072 return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase,
1076 // Otherwise, this is some other case or default statement, just ignore it.
1077 return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase,
1081 // If we are in the live part of the code and we found our break statement,
1082 // return a success!
1083 if (Case == 0 && isa<BreakStmt>(S))
1084 return CSFC_Success;
1086 // If this is a switch statement, then it might contain the SwitchCase, the
1087 // break, or neither.
1088 if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1089 // Handle this as two cases: we might be looking for the SwitchCase (if so
1090 // the skipped statements must be skippable) or we might already have it.
1091 CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end();
1093 // Keep track of whether we see a skipped declaration. The code could be
1094 // using the declaration even if it is skipped, so we can't optimize out
1095 // the decl if the kept statements might refer to it.
1096 bool HadSkippedDecl = false;
1098 // If we're looking for the case, just see if we can skip each of the
1100 for (; Case && I != E; ++I) {
1101 HadSkippedDecl |= isa<DeclStmt>(*I);
1103 switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) {
1104 case CSFC_Failure: return CSFC_Failure;
1106 // A successful result means that either 1) that the statement doesn't
1107 // have the case and is skippable, or 2) does contain the case value
1108 // and also contains the break to exit the switch. In the later case,
1109 // we just verify the rest of the statements are elidable.
1111 // If we found the case and skipped declarations, we can't do the
1114 return CSFC_Failure;
1116 for (++I; I != E; ++I)
1117 if (CodeGenFunction::ContainsLabel(*I, true))
1118 return CSFC_Failure;
1119 return CSFC_Success;
1122 case CSFC_FallThrough:
1123 // If we have a fallthrough condition, then we must have found the
1124 // case started to include statements. Consider the rest of the
1125 // statements in the compound statement as candidates for inclusion.
1126 assert(FoundCase && "Didn't find case but returned fallthrough?");
1127 // We recursively found Case, so we're not looking for it anymore.
1130 // If we found the case and skipped declarations, we can't do the
1133 return CSFC_Failure;
1139 // If we have statements in our range, then we know that the statements are
1140 // live and need to be added to the set of statements we're tracking.
1141 for (; I != E; ++I) {
1142 switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) {
1143 case CSFC_Failure: return CSFC_Failure;
1144 case CSFC_FallThrough:
1145 // A fallthrough result means that the statement was simple and just
1146 // included in ResultStmt, keep adding them afterwards.
1149 // A successful result means that we found the break statement and
1150 // stopped statement inclusion. We just ensure that any leftover stmts
1151 // are skippable and return success ourselves.
1152 for (++I; I != E; ++I)
1153 if (CodeGenFunction::ContainsLabel(*I, true))
1154 return CSFC_Failure;
1155 return CSFC_Success;
1159 return Case ? CSFC_Success : CSFC_FallThrough;
1162 // Okay, this is some other statement that we don't handle explicitly, like a
1163 // for statement or increment etc. If we are skipping over this statement,
1164 // just verify it doesn't have labels, which would make it invalid to elide.
1166 if (CodeGenFunction::ContainsLabel(S, true))
1167 return CSFC_Failure;
1168 return CSFC_Success;
1171 // Otherwise, we want to include this statement. Everything is cool with that
1172 // so long as it doesn't contain a break out of the switch we're in.
1173 if (CodeGenFunction::containsBreak(S)) return CSFC_Failure;
1175 // Otherwise, everything is great. Include the statement and tell the caller
1176 // that we fall through and include the next statement as well.
1177 ResultStmts.push_back(S);
1178 return CSFC_FallThrough;
1181 /// FindCaseStatementsForValue - Find the case statement being jumped to and
1182 /// then invoke CollectStatementsForCase to find the list of statements to emit
1183 /// for a switch on constant. See the comment above CollectStatementsForCase
1184 /// for more details.
1185 static bool FindCaseStatementsForValue(const SwitchStmt &S,
1186 const llvm::APSInt &ConstantCondValue,
1187 SmallVectorImpl<const Stmt*> &ResultStmts,
1189 // First step, find the switch case that is being branched to. We can do this
1190 // efficiently by scanning the SwitchCase list.
1191 const SwitchCase *Case = S.getSwitchCaseList();
1192 const DefaultStmt *DefaultCase = 0;
1194 for (; Case; Case = Case->getNextSwitchCase()) {
1195 // It's either a default or case. Just remember the default statement in
1196 // case we're not jumping to any numbered cases.
1197 if (const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1202 // Check to see if this case is the one we're looking for.
1203 const CaseStmt *CS = cast<CaseStmt>(Case);
1204 // Don't handle case ranges yet.
1205 if (CS->getRHS()) return false;
1207 // If we found our case, remember it as 'case'.
1208 if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue)
1212 // If we didn't find a matching case, we use a default if it exists, or we
1213 // elide the whole switch body!
1215 // It is safe to elide the body of the switch if it doesn't contain labels
1216 // etc. If it is safe, return successfully with an empty ResultStmts list.
1217 if (DefaultCase == 0)
1218 return !CodeGenFunction::ContainsLabel(&S);
1222 // Ok, we know which case is being jumped to, try to collect all the
1223 // statements that follow it. This can fail for a variety of reasons. Also,
1224 // check to see that the recursive walk actually found our case statement.
1225 // Insane cases like this can fail to find it in the recursive walk since we
1226 // don't handle every stmt kind:
1230 bool FoundCase = false;
1231 return CollectStatementsForCase(S.getBody(), Case, FoundCase,
1232 ResultStmts) != CSFC_Failure &&
1236 void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) {
1237 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog");
1239 RunCleanupsScope ConditionScope(*this);
1241 if (S.getConditionVariable())
1242 EmitAutoVarDecl(*S.getConditionVariable());
1244 // Handle nested switch statements.
1245 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1246 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1248 // See if we can constant fold the condition of the switch and therefore only
1249 // emit the live case statement (if any) of the switch.
1250 llvm::APSInt ConstantCondValue;
1251 if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) {
1252 SmallVector<const Stmt*, 4> CaseStmts;
1253 if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts,
1255 RunCleanupsScope ExecutedScope(*this);
1257 // At this point, we are no longer "within" a switch instance, so
1258 // we can temporarily enforce this to ensure that any embedded case
1259 // statements are not emitted.
1262 // Okay, we can dead code eliminate everything except this case. Emit the
1263 // specified series of statements and we're good.
1264 for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1265 EmitStmt(CaseStmts[i]);
1267 // Now we want to restore the saved switch instance so that nested
1268 // switches continue to function properly
1269 SwitchInsn = SavedSwitchInsn;
1275 llvm::Value *CondV = EmitScalarExpr(S.getCond());
1277 // Create basic block to hold stuff that comes after switch
1278 // statement. We also need to create a default block now so that
1279 // explicit case ranges tests can have a place to jump to on
1281 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default");
1282 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
1283 CaseRangeBlock = DefaultBlock;
1285 // Clear the insertion point to indicate we are in unreachable code.
1286 Builder.ClearInsertionPoint();
1288 // All break statements jump to NextBlock. If BreakContinueStack is non empty
1289 // then reuse last ContinueBlock.
1290 JumpDest OuterContinue;
1291 if (!BreakContinueStack.empty())
1292 OuterContinue = BreakContinueStack.back().ContinueBlock;
1294 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
1296 // Emit switch body.
1297 EmitStmt(S.getBody());
1299 BreakContinueStack.pop_back();
1301 // Update the default block in case explicit case range tests have
1302 // been chained on top.
1303 SwitchInsn->setDefaultDest(CaseRangeBlock);
1305 // If a default was never emitted:
1306 if (!DefaultBlock->getParent()) {
1307 // If we have cleanups, emit the default block so that there's a
1308 // place to jump through the cleanups from.
1309 if (ConditionScope.requiresCleanups()) {
1310 EmitBlock(DefaultBlock);
1312 // Otherwise, just forward the default block to the switch end.
1314 DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock());
1315 delete DefaultBlock;
1319 ConditionScope.ForceCleanup();
1321 // Emit continuation.
1322 EmitBlock(SwitchExit.getBlock(), true);
1324 SwitchInsn = SavedSwitchInsn;
1325 CaseRangeBlock = SavedCRBlock;
1329 SimplifyConstraint(const char *Constraint, const TargetInfo &Target,
1330 SmallVectorImpl<TargetInfo::ConstraintInfo> *OutCons=0) {
1333 while (*Constraint) {
1334 switch (*Constraint) {
1336 Result += Target.convertConstraint(Constraint);
1342 case '=': // Will see this and the following in mult-alt constraints.
1345 case '#': // Ignore the rest of the constraint alternative.
1346 while (Constraint[1] && Constraint[1] != ',')
1357 "Must pass output names to constraints with a symbolic name");
1359 bool result = Target.resolveSymbolicName(Constraint,
1361 OutCons->size(), Index);
1362 assert(result && "Could not resolve symbolic name"); (void)result;
1363 Result += llvm::utostr(Index);
1374 /// AddVariableConstraints - Look at AsmExpr and if it is a variable declared
1375 /// as using a particular register add that as a constraint that will be used
1376 /// in this asm stmt.
1378 AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
1379 const TargetInfo &Target, CodeGenModule &CGM,
1380 const AsmStmt &Stmt) {
1381 const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);
1384 const ValueDecl &Value = *AsmDeclRef->getDecl();
1385 const VarDecl *Variable = dyn_cast<VarDecl>(&Value);
1388 if (Variable->getStorageClass() != SC_Register)
1390 AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>();
1393 StringRef Register = Attr->getLabel();
1394 assert(Target.isValidGCCRegisterName(Register));
1395 // We're using validateOutputConstraint here because we only care if
1396 // this is a register constraint.
1397 TargetInfo::ConstraintInfo Info(Constraint, "");
1398 if (Target.validateOutputConstraint(Info) &&
1399 !Info.allowsRegister()) {
1400 CGM.ErrorUnsupported(&Stmt, "__asm__");
1403 // Canonicalize the register here before returning it.
1404 Register = Target.getNormalizedGCCRegisterName(Register);
1405 return "{" + Register.str() + "}";
1409 CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info,
1410 LValue InputValue, QualType InputType,
1411 std::string &ConstraintStr,
1412 SourceLocation Loc) {
1414 if (Info.allowsRegister() || !Info.allowsMemory()) {
1415 if (CodeGenFunction::hasScalarEvaluationKind(InputType)) {
1416 Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal();
1418 llvm::Type *Ty = ConvertType(InputType);
1419 uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty);
1420 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
1421 Ty = llvm::IntegerType::get(getLLVMContext(), Size);
1422 Ty = llvm::PointerType::getUnqual(Ty);
1424 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1427 Arg = InputValue.getAddress();
1428 ConstraintStr += '*';
1432 Arg = InputValue.getAddress();
1433 ConstraintStr += '*';
1439 llvm::Value* CodeGenFunction::EmitAsmInput(
1440 const TargetInfo::ConstraintInfo &Info,
1441 const Expr *InputExpr,
1442 std::string &ConstraintStr) {
1443 if (Info.allowsRegister() || !Info.allowsMemory())
1444 if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType()))
1445 return EmitScalarExpr(InputExpr);
1447 InputExpr = InputExpr->IgnoreParenNoopCasts(getContext());
1448 LValue Dest = EmitLValue(InputExpr);
1449 return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr,
1450 InputExpr->getExprLoc());
1453 /// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline
1454 /// asm call instruction. The !srcloc MDNode contains a list of constant
1455 /// integers which are the source locations of the start of each line in the
1457 static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
1458 CodeGenFunction &CGF) {
1459 SmallVector<llvm::Value *, 8> Locs;
1460 // Add the location of the first line to the MDNode.
1461 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1462 Str->getLocStart().getRawEncoding()));
1463 StringRef StrVal = Str->getString();
1464 if (!StrVal.empty()) {
1465 const SourceManager &SM = CGF.CGM.getContext().getSourceManager();
1466 const LangOptions &LangOpts = CGF.CGM.getLangOpts();
1468 // Add the location of the start of each subsequent line of the asm to the
1470 for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) {
1471 if (StrVal[i] != '\n') continue;
1472 SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts,
1474 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1475 LineLoc.getRawEncoding()));
1479 return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
1482 void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
1483 // Assemble the final asm string.
1484 std::string AsmString = S.generateAsmString(getContext());
1486 // Get all the output and input constraints together.
1487 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1488 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1490 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
1492 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1493 Name = GAS->getOutputName(i);
1494 TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name);
1495 bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid;
1496 assert(IsValid && "Failed to parse output constraint");
1497 OutputConstraintInfos.push_back(Info);
1500 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1502 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1503 Name = GAS->getInputName(i);
1504 TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name);
1506 getTarget().validateInputConstraint(OutputConstraintInfos.data(),
1507 S.getNumOutputs(), Info);
1508 assert(IsValid && "Failed to parse input constraint"); (void)IsValid;
1509 InputConstraintInfos.push_back(Info);
1512 std::string Constraints;
1514 std::vector<LValue> ResultRegDests;
1515 std::vector<QualType> ResultRegQualTys;
1516 std::vector<llvm::Type *> ResultRegTypes;
1517 std::vector<llvm::Type *> ResultTruncRegTypes;
1518 std::vector<llvm::Type *> ArgTypes;
1519 std::vector<llvm::Value*> Args;
1521 // Keep track of inout constraints.
1522 std::string InOutConstraints;
1523 std::vector<llvm::Value*> InOutArgs;
1524 std::vector<llvm::Type*> InOutArgTypes;
1526 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
1527 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
1529 // Simplify the output constraint.
1530 std::string OutputConstraint(S.getOutputConstraint(i));
1531 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1,
1534 const Expr *OutExpr = S.getOutputExpr(i);
1535 OutExpr = OutExpr->IgnoreParenNoopCasts(getContext());
1537 OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr,
1538 getTarget(), CGM, S);
1540 LValue Dest = EmitLValue(OutExpr);
1541 if (!Constraints.empty())
1544 // If this is a register output, then make the inline asm return it
1545 // by-value. If this is a memory result, return the value by-reference.
1546 if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) {
1547 Constraints += "=" + OutputConstraint;
1548 ResultRegQualTys.push_back(OutExpr->getType());
1549 ResultRegDests.push_back(Dest);
1550 ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType()));
1551 ResultTruncRegTypes.push_back(ResultRegTypes.back());
1553 // If this output is tied to an input, and if the input is larger, then
1554 // we need to set the actual result type of the inline asm node to be the
1555 // same as the input type.
1556 if (Info.hasMatchingInput()) {
1558 for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) {
1559 TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo];
1560 if (Input.hasTiedOperand() && Input.getTiedOperand() == i)
1563 assert(InputNo != S.getNumInputs() && "Didn't find matching input!");
1565 QualType InputTy = S.getInputExpr(InputNo)->getType();
1566 QualType OutputType = OutExpr->getType();
1568 uint64_t InputSize = getContext().getTypeSize(InputTy);
1569 if (getContext().getTypeSize(OutputType) < InputSize) {
1570 // Form the asm to return the value as a larger integer or fp type.
1571 ResultRegTypes.back() = ConvertType(InputTy);
1574 if (llvm::Type* AdjTy =
1575 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1576 ResultRegTypes.back()))
1577 ResultRegTypes.back() = AdjTy;
1579 CGM.getDiags().Report(S.getAsmLoc(),
1580 diag::err_asm_invalid_type_in_input)
1581 << OutExpr->getType() << OutputConstraint;
1584 ArgTypes.push_back(Dest.getAddress()->getType());
1585 Args.push_back(Dest.getAddress());
1586 Constraints += "=*";
1587 Constraints += OutputConstraint;
1590 if (Info.isReadWrite()) {
1591 InOutConstraints += ',';
1593 const Expr *InputExpr = S.getOutputExpr(i);
1594 llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(),
1596 InputExpr->getExprLoc());
1598 if (llvm::Type* AdjTy =
1599 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1601 Arg = Builder.CreateBitCast(Arg, AdjTy);
1603 if (Info.allowsRegister())
1604 InOutConstraints += llvm::utostr(i);
1606 InOutConstraints += OutputConstraint;
1608 InOutArgTypes.push_back(Arg->getType());
1609 InOutArgs.push_back(Arg);
1613 unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs();
1615 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1616 const Expr *InputExpr = S.getInputExpr(i);
1618 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1620 if (!Constraints.empty())
1623 // Simplify the input constraint.
1624 std::string InputConstraint(S.getInputConstraint(i));
1625 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(),
1626 &OutputConstraintInfos);
1629 AddVariableConstraints(InputConstraint,
1630 *InputExpr->IgnoreParenNoopCasts(getContext()),
1631 getTarget(), CGM, S);
1633 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
1635 // If this input argument is tied to a larger output result, extend the
1636 // input to be the same size as the output. The LLVM backend wants to see
1637 // the input and output of a matching constraint be the same size. Note
1638 // that GCC does not define what the top bits are here. We use zext because
1639 // that is usually cheaper, but LLVM IR should really get an anyext someday.
1640 if (Info.hasTiedOperand()) {
1641 unsigned Output = Info.getTiedOperand();
1642 QualType OutputType = S.getOutputExpr(Output)->getType();
1643 QualType InputTy = InputExpr->getType();
1645 if (getContext().getTypeSize(OutputType) >
1646 getContext().getTypeSize(InputTy)) {
1647 // Use ptrtoint as appropriate so that we can do our extension.
1648 if (isa<llvm::PointerType>(Arg->getType()))
1649 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy);
1650 llvm::Type *OutputTy = ConvertType(OutputType);
1651 if (isa<llvm::IntegerType>(OutputTy))
1652 Arg = Builder.CreateZExt(Arg, OutputTy);
1653 else if (isa<llvm::PointerType>(OutputTy))
1654 Arg = Builder.CreateZExt(Arg, IntPtrTy);
1656 assert(OutputTy->isFloatingPointTy() && "Unexpected output type");
1657 Arg = Builder.CreateFPExt(Arg, OutputTy);
1661 if (llvm::Type* AdjTy =
1662 getTargetHooks().adjustInlineAsmType(*this, InputConstraint,
1664 Arg = Builder.CreateBitCast(Arg, AdjTy);
1666 CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input)
1667 << InputExpr->getType() << InputConstraint;
1669 ArgTypes.push_back(Arg->getType());
1670 Args.push_back(Arg);
1671 Constraints += InputConstraint;
1674 // Append the "input" part of inout constraints last.
1675 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
1676 ArgTypes.push_back(InOutArgTypes[i]);
1677 Args.push_back(InOutArgs[i]);
1679 Constraints += InOutConstraints;
1682 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
1683 StringRef Clobber = S.getClobber(i);
1685 if (Clobber != "memory" && Clobber != "cc")
1686 Clobber = getTarget().getNormalizedGCCRegisterName(Clobber);
1688 if (i != 0 || NumConstraints != 0)
1691 Constraints += "~{";
1692 Constraints += Clobber;
1696 // Add machine specific clobbers
1697 std::string MachineClobbers = getTarget().getClobbers();
1698 if (!MachineClobbers.empty()) {
1699 if (!Constraints.empty())
1701 Constraints += MachineClobbers;
1704 llvm::Type *ResultType;
1705 if (ResultRegTypes.empty())
1706 ResultType = VoidTy;
1707 else if (ResultRegTypes.size() == 1)
1708 ResultType = ResultRegTypes[0];
1710 ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes);
1712 llvm::FunctionType *FTy =
1713 llvm::FunctionType::get(ResultType, ArgTypes, false);
1715 bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0;
1716 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?
1717 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
1718 llvm::InlineAsm *IA =
1719 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
1720 /* IsAlignStack */ false, AsmDialect);
1721 llvm::CallInst *Result = Builder.CreateCall(IA, Args);
1722 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
1723 llvm::Attribute::NoUnwind);
1725 // Slap the source location of the inline asm into a !srcloc metadata on the
1726 // call. FIXME: Handle metadata for MS-style inline asms.
1727 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S))
1728 Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(),
1731 // Extract all of the register value results from the asm.
1732 std::vector<llvm::Value*> RegResults;
1733 if (ResultRegTypes.size() == 1) {
1734 RegResults.push_back(Result);
1736 for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
1737 llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult");
1738 RegResults.push_back(Tmp);
1742 for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {
1743 llvm::Value *Tmp = RegResults[i];
1745 // If the result type of the LLVM IR asm doesn't match the result type of
1746 // the expression, do the conversion.
1747 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
1748 llvm::Type *TruncTy = ResultTruncRegTypes[i];
1750 // Truncate the integer result to the right size, note that TruncTy can be
1752 if (TruncTy->isFloatingPointTy())
1753 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy);
1754 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
1755 uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy);
1756 Tmp = Builder.CreateTrunc(Tmp,
1757 llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize));
1758 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy);
1759 } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
1760 uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType());
1761 Tmp = Builder.CreatePtrToInt(Tmp,
1762 llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize));
1763 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
1764 } else if (TruncTy->isIntegerTy()) {
1765 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
1766 } else if (TruncTy->isVectorTy()) {
1767 Tmp = Builder.CreateBitCast(Tmp, TruncTy);
1771 EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]);
1775 static LValue InitCapturedStruct(CodeGenFunction &CGF, const CapturedStmt &S) {
1776 const RecordDecl *RD = S.getCapturedRecordDecl();
1777 QualType RecordTy = CGF.getContext().getRecordType(RD);
1779 // Initialize the captured struct.
1780 LValue SlotLV = CGF.MakeNaturalAlignAddrLValue(
1781 CGF.CreateMemTemp(RecordTy, "agg.captured"), RecordTy);
1783 RecordDecl::field_iterator CurField = RD->field_begin();
1784 for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(),
1785 E = S.capture_init_end();
1786 I != E; ++I, ++CurField) {
1787 LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField);
1788 CGF.EmitInitializerForField(*CurField, LV, *I, ArrayRef<VarDecl *>());
1794 /// Generate an outlined function for the body of a CapturedStmt, store any
1795 /// captured variables into the captured struct, and call the outlined function.
1797 CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) {
1798 const CapturedDecl *CD = S.getCapturedDecl();
1799 const RecordDecl *RD = S.getCapturedRecordDecl();
1800 assert(CD->hasBody() && "missing CapturedDecl body");
1802 LValue CapStruct = InitCapturedStruct(*this, S);
1804 // Emit the CapturedDecl
1805 CodeGenFunction CGF(CGM, true);
1806 CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K);
1807 llvm::Function *F = CGF.GenerateCapturedStmtFunction(CD, RD, S.getLocStart());
1808 delete CGF.CapturedStmtInfo;
1810 // Emit call to the helper function.
1811 EmitCallOrInvoke(F, CapStruct.getAddress());
1816 /// Creates the outlined function for a CapturedStmt.
1818 CodeGenFunction::GenerateCapturedStmtFunction(const CapturedDecl *CD,
1819 const RecordDecl *RD,
1820 SourceLocation Loc) {
1821 assert(CapturedStmtInfo &&
1822 "CapturedStmtInfo should be set when generating the captured function");
1824 // Build the argument list.
1825 ASTContext &Ctx = CGM.getContext();
1826 FunctionArgList Args;
1827 Args.append(CD->param_begin(), CD->param_end());
1829 // Create the function declaration.
1830 FunctionType::ExtInfo ExtInfo;
1831 const CGFunctionInfo &FuncInfo =
1832 CGM.getTypes().arrangeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo,
1833 /*IsVariadic=*/false);
1834 llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo);
1837 llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,
1838 CapturedStmtInfo->getHelperName(), &CGM.getModule());
1839 CGM.SetInternalFunctionAttributes(CD, F, FuncInfo);
1841 // Generate the function.
1842 StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getBody()->getLocStart());
1844 // Set the context parameter in CapturedStmtInfo.
1845 llvm::Value *DeclPtr = LocalDeclMap[CD->getContextParam()];
1846 assert(DeclPtr && "missing context parameter for CapturedStmt");
1847 CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr));
1849 // If 'this' is captured, load it into CXXThisValue.
1850 if (CapturedStmtInfo->isCXXThisExprCaptured()) {
1851 FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl();
1852 LValue LV = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(),
1853 Ctx.getTagDeclType(RD));
1854 LValue ThisLValue = EmitLValueForField(LV, FD);
1855 CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal();
1858 CapturedStmtInfo->EmitBody(*this, CD->getBody());
1859 FinishFunction(CD->getBodyRBrace());