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 "CGDebugInfo.h"
15 #include "CodeGenModule.h"
16 #include "CodeGenFunction.h"
17 #include "TargetInfo.h"
18 #include "clang/AST/StmtVisitor.h"
19 #include "clang/Basic/PrettyStackTrace.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/InlineAsm.h"
23 #include "llvm/Intrinsics.h"
24 #include "llvm/Target/TargetData.h"
25 using namespace clang;
26 using namespace CodeGen;
28 //===----------------------------------------------------------------------===//
30 //===----------------------------------------------------------------------===//
32 void CodeGenFunction::EmitStopPoint(const Stmt *S) {
33 if (CGDebugInfo *DI = getDebugInfo()) {
38 Loc = S->getLocStart();
39 DI->EmitLocation(Builder, Loc);
43 void CodeGenFunction::EmitStmt(const Stmt *S) {
44 assert(S && "Null statement?");
46 // These statements have their own debug info handling.
47 if (EmitSimpleStmt(S))
50 // Check if we are generating unreachable code.
51 if (!HaveInsertPoint()) {
52 // If so, and the statement doesn't contain a label, then we do not need to
53 // generate actual code. This is safe because (1) the current point is
54 // unreachable, so we don't need to execute the code, and (2) we've already
55 // handled the statements which update internal data structures (like the
56 // local variable map) which could be used by subsequent statements.
57 if (!ContainsLabel(S)) {
58 // Verify that any decl statements were handled as simple, they may be in
59 // scope of subsequent reachable statements.
60 assert(!isa<DeclStmt>(*S) && "Unexpected DeclStmt!");
64 // Otherwise, make a new block to hold the code.
68 // Generate a stoppoint if we are emitting debug info.
71 switch (S->getStmtClass()) {
72 case Stmt::NoStmtClass:
73 case Stmt::CXXCatchStmtClass:
74 case Stmt::SEHExceptStmtClass:
75 case Stmt::SEHFinallyStmtClass:
76 llvm_unreachable("invalid statement class to emit generically");
77 case Stmt::NullStmtClass:
78 case Stmt::CompoundStmtClass:
79 case Stmt::DeclStmtClass:
80 case Stmt::LabelStmtClass:
81 case Stmt::GotoStmtClass:
82 case Stmt::BreakStmtClass:
83 case Stmt::ContinueStmtClass:
84 case Stmt::DefaultStmtClass:
85 case Stmt::CaseStmtClass:
86 llvm_unreachable("should have emitted these statements as simple");
88 #define STMT(Type, Base)
89 #define ABSTRACT_STMT(Op)
90 #define EXPR(Type, Base) \
91 case Stmt::Type##Class:
92 #include "clang/AST/StmtNodes.inc"
94 // Remember the block we came in on.
95 llvm::BasicBlock *incoming = Builder.GetInsertBlock();
96 assert(incoming && "expression emission must have an insertion point");
98 EmitIgnoredExpr(cast<Expr>(S));
100 llvm::BasicBlock *outgoing = Builder.GetInsertBlock();
101 assert(outgoing && "expression emission cleared block!");
103 // The expression emitters assume (reasonably!) that the insertion
104 // point is always set. To maintain that, the call-emission code
105 // for noreturn functions has to enter a new block with no
106 // predecessors. We want to kill that block and mark the current
107 // insertion point unreachable in the common case of a call like
108 // "exit();". Since expression emission doesn't otherwise create
109 // blocks with no predecessors, we can just test for that.
110 // However, we must be careful not to do this to our incoming
111 // block, because *statement* emission does sometimes create
112 // reachable blocks which will have no predecessors until later in
113 // the function. This occurs with, e.g., labels that are not
114 // reachable by fallthrough.
115 if (incoming != outgoing && outgoing->use_empty()) {
116 outgoing->eraseFromParent();
117 Builder.ClearInsertionPoint();
122 case Stmt::IndirectGotoStmtClass:
123 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break;
125 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break;
126 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break;
127 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break;
128 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break;
130 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break;
132 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break;
133 case Stmt::AsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break;
135 case Stmt::ObjCAtTryStmtClass:
136 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
138 case Stmt::ObjCAtCatchStmtClass:
140 "@catch statements should be handled by EmitObjCAtTryStmt");
141 case Stmt::ObjCAtFinallyStmtClass:
143 "@finally statements should be handled by EmitObjCAtTryStmt");
144 case Stmt::ObjCAtThrowStmtClass:
145 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
147 case Stmt::ObjCAtSynchronizedStmtClass:
148 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S));
150 case Stmt::ObjCForCollectionStmtClass:
151 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
153 case Stmt::ObjCAutoreleasePoolStmtClass:
154 EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S));
157 case Stmt::CXXTryStmtClass:
158 EmitCXXTryStmt(cast<CXXTryStmt>(*S));
160 case Stmt::CXXForRangeStmtClass:
161 EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S));
162 case Stmt::SEHTryStmtClass:
163 // FIXME Not yet implemented
168 bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
169 switch (S->getStmtClass()) {
170 default: return false;
171 case Stmt::NullStmtClass: break;
172 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
173 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break;
174 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break;
175 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break;
176 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break;
177 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break;
178 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break;
179 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break;
185 /// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true,
186 /// this captures the expression result of the last sub-statement and returns it
187 /// (for use by the statement expression extension).
188 RValue CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
189 AggValueSlot AggSlot) {
190 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(),
191 "LLVM IR generation of compound statement ('{}')");
193 CGDebugInfo *DI = getDebugInfo();
195 DI->EmitLexicalBlockStart(Builder, S.getLBracLoc());
197 // Keep track of the current cleanup stack depth.
198 RunCleanupsScope Scope(*this);
200 for (CompoundStmt::const_body_iterator I = S.body_begin(),
201 E = S.body_end()-GetLast; I != E; ++I)
205 DI->EmitLexicalBlockEnd(Builder, S.getRBracLoc());
211 // We have to special case labels here. They are statements, but when put
212 // at the end of a statement expression, they yield the value of their
213 // subexpression. Handle this by walking through all labels we encounter,
214 // emitting them before we evaluate the subexpr.
215 const Stmt *LastStmt = S.body_back();
216 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
217 EmitLabel(LS->getDecl());
218 LastStmt = LS->getSubStmt();
223 RV = EmitAnyExpr(cast<Expr>(LastStmt), AggSlot);
229 void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) {
230 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
232 // If there is a cleanup stack, then we it isn't worth trying to
233 // simplify this block (we would need to remove it from the scope map
234 // and cleanup entry).
235 if (!EHStack.empty())
238 // Can only simplify direct branches.
239 if (!BI || !BI->isUnconditional())
242 BB->replaceAllUsesWith(BI->getSuccessor(0));
243 BI->eraseFromParent();
244 BB->eraseFromParent();
247 void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) {
248 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
250 // Fall out of the current block (if necessary).
253 if (IsFinished && BB->use_empty()) {
258 // Place the block after the current block, if possible, or else at
259 // the end of the function.
260 if (CurBB && CurBB->getParent())
261 CurFn->getBasicBlockList().insertAfter(CurBB, BB);
263 CurFn->getBasicBlockList().push_back(BB);
264 Builder.SetInsertPoint(BB);
267 void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) {
268 // Emit a branch from the current block to the target one if this
269 // was a real block. If this was just a fall-through block after a
270 // terminator, don't emit it.
271 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
273 if (!CurBB || CurBB->getTerminator()) {
274 // If there is no insert point or the previous block is already
275 // terminated, don't touch it.
277 // Otherwise, create a fall-through branch.
278 Builder.CreateBr(Target);
281 Builder.ClearInsertionPoint();
284 void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) {
285 bool inserted = false;
286 for (llvm::BasicBlock::use_iterator
287 i = block->use_begin(), e = block->use_end(); i != e; ++i) {
288 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(*i)) {
289 CurFn->getBasicBlockList().insertAfter(insn->getParent(), block);
296 CurFn->getBasicBlockList().push_back(block);
298 Builder.SetInsertPoint(block);
301 CodeGenFunction::JumpDest
302 CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) {
303 JumpDest &Dest = LabelMap[D];
304 if (Dest.isValid()) return Dest;
306 // Create, but don't insert, the new block.
307 Dest = JumpDest(createBasicBlock(D->getName()),
308 EHScopeStack::stable_iterator::invalid(),
309 NextCleanupDestIndex++);
313 void CodeGenFunction::EmitLabel(const LabelDecl *D) {
314 JumpDest &Dest = LabelMap[D];
316 // If we didn't need a forward reference to this label, just go
317 // ahead and create a destination at the current scope.
318 if (!Dest.isValid()) {
319 Dest = getJumpDestInCurrentScope(D->getName());
321 // Otherwise, we need to give this label a target depth and remove
322 // it from the branch-fixups list.
324 assert(!Dest.getScopeDepth().isValid() && "already emitted label!");
325 Dest = JumpDest(Dest.getBlock(),
326 EHStack.stable_begin(),
327 Dest.getDestIndex());
329 ResolveBranchFixups(Dest.getBlock());
332 EmitBlock(Dest.getBlock());
336 void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
337 EmitLabel(S.getDecl());
338 EmitStmt(S.getSubStmt());
341 void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
342 // If this code is reachable then emit a stop point (if generating
343 // debug info). We have to do this ourselves because we are on the
344 // "simple" statement path.
345 if (HaveInsertPoint())
348 EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel()));
352 void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
353 if (const LabelDecl *Target = S.getConstantTarget()) {
354 EmitBranchThroughCleanup(getJumpDestForLabel(Target));
358 // Ensure that we have an i8* for our PHI node.
359 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
361 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
364 // Get the basic block for the indirect goto.
365 llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock();
367 // The first instruction in the block has to be the PHI for the switch dest,
368 // add an entry for this branch.
369 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
371 EmitBranch(IndGotoBB);
374 void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
375 // C99 6.8.4.1: The first substatement is executed if the expression compares
376 // unequal to 0. The condition must be a scalar type.
377 RunCleanupsScope ConditionScope(*this);
379 if (S.getConditionVariable())
380 EmitAutoVarDecl(*S.getConditionVariable());
382 // If the condition constant folds and can be elided, try to avoid emitting
383 // the condition and the dead arm of the if/else.
385 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) {
386 // Figure out which block (then or else) is executed.
387 const Stmt *Executed = S.getThen();
388 const Stmt *Skipped = S.getElse();
389 if (!CondConstant) // Condition false?
390 std::swap(Executed, Skipped);
392 // If the skipped block has no labels in it, just emit the executed block.
393 // This avoids emitting dead code and simplifies the CFG substantially.
394 if (!ContainsLabel(Skipped)) {
396 RunCleanupsScope ExecutedScope(*this);
403 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit
404 // the conditional branch.
405 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then");
406 llvm::BasicBlock *ContBlock = createBasicBlock("if.end");
407 llvm::BasicBlock *ElseBlock = ContBlock;
409 ElseBlock = createBasicBlock("if.else");
410 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock);
412 // Emit the 'then' code.
413 EmitBlock(ThenBlock);
415 RunCleanupsScope ThenScope(*this);
416 EmitStmt(S.getThen());
418 EmitBranch(ContBlock);
420 // Emit the 'else' code if present.
421 if (const Stmt *Else = S.getElse()) {
422 // There is no need to emit line number for unconditional branch.
424 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
425 EmitBlock(ElseBlock);
427 RunCleanupsScope ElseScope(*this);
430 // There is no need to emit line number for unconditional branch.
432 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
433 EmitBranch(ContBlock);
436 // Emit the continuation block for code after the if.
437 EmitBlock(ContBlock, true);
440 void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) {
441 // Emit the header for the loop, which will also become
442 // the continue target.
443 JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond");
444 EmitBlock(LoopHeader.getBlock());
446 // Create an exit block for when the condition fails, which will
447 // also become the break target.
448 JumpDest LoopExit = getJumpDestInCurrentScope("while.end");
450 // Store the blocks to use for break and continue.
451 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
453 // C++ [stmt.while]p2:
454 // When the condition of a while statement is a declaration, the
455 // scope of the variable that is declared extends from its point
456 // of declaration (3.3.2) to the end of the while statement.
458 // The object created in a condition is destroyed and created
459 // with each iteration of the loop.
460 RunCleanupsScope ConditionScope(*this);
462 if (S.getConditionVariable())
463 EmitAutoVarDecl(*S.getConditionVariable());
465 // Evaluate the conditional in the while header. C99 6.8.5.1: The
466 // evaluation of the controlling expression takes place before each
467 // execution of the loop body.
468 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
470 // while(1) is common, avoid extra exit blocks. Be sure
471 // to correctly handle break/continue though.
472 bool EmitBoolCondBranch = true;
473 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
475 EmitBoolCondBranch = false;
477 // As long as the condition is true, go to the loop body.
478 llvm::BasicBlock *LoopBody = createBasicBlock("while.body");
479 if (EmitBoolCondBranch) {
480 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
481 if (ConditionScope.requiresCleanups())
482 ExitBlock = createBasicBlock("while.exit");
484 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock);
486 if (ExitBlock != LoopExit.getBlock()) {
487 EmitBlock(ExitBlock);
488 EmitBranchThroughCleanup(LoopExit);
492 // Emit the loop body. We have to emit this in a cleanup scope
493 // because it might be a singleton DeclStmt.
495 RunCleanupsScope BodyScope(*this);
497 EmitStmt(S.getBody());
500 BreakContinueStack.pop_back();
502 // Immediately force cleanup.
503 ConditionScope.ForceCleanup();
505 // Branch to the loop header again.
506 EmitBranch(LoopHeader.getBlock());
508 // Emit the exit block.
509 EmitBlock(LoopExit.getBlock(), true);
511 // The LoopHeader typically is just a branch if we skipped emitting
512 // a branch, try to erase it.
513 if (!EmitBoolCondBranch)
514 SimplifyForwardingBlocks(LoopHeader.getBlock());
517 void CodeGenFunction::EmitDoStmt(const DoStmt &S) {
518 JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
519 JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
521 // Store the blocks to use for break and continue.
522 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
524 // Emit the body of the loop.
525 llvm::BasicBlock *LoopBody = createBasicBlock("do.body");
528 RunCleanupsScope BodyScope(*this);
529 EmitStmt(S.getBody());
532 BreakContinueStack.pop_back();
534 EmitBlock(LoopCond.getBlock());
536 // C99 6.8.5.2: "The evaluation of the controlling expression takes place
537 // after each execution of the loop body."
539 // Evaluate the conditional in the while header.
540 // C99 6.8.5p2/p4: The first substatement is executed if the expression
541 // compares unequal to 0. The condition must be a scalar type.
542 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
544 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure
545 // to correctly handle break/continue though.
546 bool EmitBoolCondBranch = true;
547 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
549 EmitBoolCondBranch = false;
551 // As long as the condition is true, iterate the loop.
552 if (EmitBoolCondBranch)
553 Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock());
555 // Emit the exit block.
556 EmitBlock(LoopExit.getBlock());
558 // The DoCond block typically is just a branch if we skipped
559 // emitting a branch, try to erase it.
560 if (!EmitBoolCondBranch)
561 SimplifyForwardingBlocks(LoopCond.getBlock());
564 void CodeGenFunction::EmitForStmt(const ForStmt &S) {
565 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
567 RunCleanupsScope ForScope(*this);
569 CGDebugInfo *DI = getDebugInfo();
571 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
573 // Evaluate the first part before the loop.
575 EmitStmt(S.getInit());
577 // Start the loop with a block that tests the condition.
578 // If there's an increment, the continue scope will be overwritten
580 JumpDest Continue = getJumpDestInCurrentScope("for.cond");
581 llvm::BasicBlock *CondBlock = Continue.getBlock();
582 EmitBlock(CondBlock);
584 // Create a cleanup scope for the condition variable cleanups.
585 RunCleanupsScope ConditionScope(*this);
587 llvm::Value *BoolCondVal = 0;
589 // If the for statement has a condition scope, emit the local variable
591 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
592 if (S.getConditionVariable()) {
593 EmitAutoVarDecl(*S.getConditionVariable());
596 // If there are any cleanups between here and the loop-exit scope,
597 // create a block to stage a loop exit along.
598 if (ForScope.requiresCleanups())
599 ExitBlock = createBasicBlock("for.cond.cleanup");
601 // As long as the condition is true, iterate the loop.
602 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
604 // C99 6.8.5p2/p4: The first substatement is executed if the expression
605 // compares unequal to 0. The condition must be a scalar type.
606 BoolCondVal = EvaluateExprAsBool(S.getCond());
607 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock);
609 if (ExitBlock != LoopExit.getBlock()) {
610 EmitBlock(ExitBlock);
611 EmitBranchThroughCleanup(LoopExit);
616 // Treat it as a non-zero constant. Don't even create a new block for the
617 // body, just fall into it.
620 // If the for loop doesn't have an increment we can just use the
621 // condition as the continue block. Otherwise we'll need to create
622 // a block for it (in the current scope, i.e. in the scope of the
623 // condition), and that we will become our continue block.
625 Continue = getJumpDestInCurrentScope("for.inc");
627 // Store the blocks to use for break and continue.
628 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
631 // Create a separate cleanup scope for the body, in case it is not
632 // a compound statement.
633 RunCleanupsScope BodyScope(*this);
634 EmitStmt(S.getBody());
637 // If there is an increment, emit it next.
639 EmitBlock(Continue.getBlock());
640 EmitStmt(S.getInc());
643 BreakContinueStack.pop_back();
645 ConditionScope.ForceCleanup();
646 EmitBranch(CondBlock);
648 ForScope.ForceCleanup();
651 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
653 // Emit the fall-through block.
654 EmitBlock(LoopExit.getBlock(), true);
657 void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) {
658 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
660 RunCleanupsScope ForScope(*this);
662 CGDebugInfo *DI = getDebugInfo();
664 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
666 // Evaluate the first pieces before the loop.
667 EmitStmt(S.getRangeStmt());
668 EmitStmt(S.getBeginEndStmt());
670 // Start the loop with a block that tests the condition.
671 // If there's an increment, the continue scope will be overwritten
673 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
674 EmitBlock(CondBlock);
676 // If there are any cleanups between here and the loop-exit scope,
677 // create a block to stage a loop exit along.
678 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
679 if (ForScope.requiresCleanups())
680 ExitBlock = createBasicBlock("for.cond.cleanup");
682 // The loop body, consisting of the specified body and the loop variable.
683 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
685 // The body is executed if the expression, contextually converted
687 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
688 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock);
690 if (ExitBlock != LoopExit.getBlock()) {
691 EmitBlock(ExitBlock);
692 EmitBranchThroughCleanup(LoopExit);
697 // Create a block for the increment. In case of a 'continue', we jump there.
698 JumpDest Continue = getJumpDestInCurrentScope("for.inc");
700 // Store the blocks to use for break and continue.
701 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
704 // Create a separate cleanup scope for the loop variable and body.
705 RunCleanupsScope BodyScope(*this);
706 EmitStmt(S.getLoopVarStmt());
707 EmitStmt(S.getBody());
710 // If there is an increment, emit it next.
711 EmitBlock(Continue.getBlock());
712 EmitStmt(S.getInc());
714 BreakContinueStack.pop_back();
716 EmitBranch(CondBlock);
718 ForScope.ForceCleanup();
721 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
723 // Emit the fall-through block.
724 EmitBlock(LoopExit.getBlock(), true);
727 void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) {
729 Builder.CreateStore(RV.getScalarVal(), ReturnValue);
730 } else if (RV.isAggregate()) {
731 EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty);
733 StoreComplexToAddr(RV.getComplexVal(), ReturnValue, false);
735 EmitBranchThroughCleanup(ReturnBlock);
738 /// EmitReturnStmt - Note that due to GCC extensions, this can have an operand
739 /// if the function returns void, or may be missing one if the function returns
740 /// non-void. Fun stuff :).
741 void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
742 // Emit the result value, even if unused, to evalute the side effects.
743 const Expr *RV = S.getRetValue();
745 // FIXME: Clean this up by using an LValue for ReturnTemp,
746 // EmitStoreThroughLValue, and EmitAnyExpr.
747 if (S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable() &&
748 !Target.useGlobalsForAutomaticVariables()) {
749 // Apply the named return value optimization for this return statement,
750 // which means doing nothing: the appropriate result has already been
751 // constructed into the NRVO variable.
753 // If there is an NRVO flag for this variable, set it to 1 into indicate
754 // that the cleanup code should not destroy the variable.
755 if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()])
756 Builder.CreateStore(Builder.getTrue(), NRVOFlag);
757 } else if (!ReturnValue) {
758 // Make sure not to return anything, but evaluate the expression
762 } else if (RV == 0) {
763 // Do nothing (return value is left uninitialized)
764 } else if (FnRetTy->isReferenceType()) {
765 // If this function returns a reference, take the address of the expression
766 // rather than the value.
767 RValue Result = EmitReferenceBindingToExpr(RV, /*InitializedDecl=*/0);
768 Builder.CreateStore(Result.getScalarVal(), ReturnValue);
769 } else if (!hasAggregateLLVMType(RV->getType())) {
770 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue);
771 } else if (RV->getType()->isAnyComplexType()) {
772 EmitComplexExprIntoAddr(RV, ReturnValue, false);
774 EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Qualifiers(),
775 AggValueSlot::IsDestructed,
776 AggValueSlot::DoesNotNeedGCBarriers,
777 AggValueSlot::IsNotAliased));
780 EmitBranchThroughCleanup(ReturnBlock);
783 void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
784 // As long as debug info is modeled with instructions, we have to ensure we
785 // have a place to insert here and write the stop point here.
786 if (getDebugInfo() && HaveInsertPoint())
789 for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end();
794 void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) {
795 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
797 // If this code is reachable then emit a stop point (if generating
798 // debug info). We have to do this ourselves because we are on the
799 // "simple" statement path.
800 if (HaveInsertPoint())
803 JumpDest Block = BreakContinueStack.back().BreakBlock;
804 EmitBranchThroughCleanup(Block);
807 void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) {
808 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
810 // If this code is reachable then emit a stop point (if generating
811 // debug info). We have to do this ourselves because we are on the
812 // "simple" statement path.
813 if (HaveInsertPoint())
816 JumpDest Block = BreakContinueStack.back().ContinueBlock;
817 EmitBranchThroughCleanup(Block);
820 /// EmitCaseStmtRange - If case statement range is not too big then
821 /// add multiple cases to switch instruction, one for each value within
822 /// the range. If range is too big then emit "if" condition check.
823 void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
824 assert(S.getRHS() && "Expected RHS value in CaseStmt");
826 llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext());
827 llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext());
829 // Emit the code for this case. We do this first to make sure it is
830 // properly chained from our predecessor before generating the
831 // switch machinery to enter this block.
832 EmitBlock(createBasicBlock("sw.bb"));
833 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
834 EmitStmt(S.getSubStmt());
836 // If range is empty, do nothing.
837 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
840 llvm::APInt Range = RHS - LHS;
841 // FIXME: parameters such as this should not be hardcoded.
842 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
843 // Range is small enough to add multiple switch instruction cases.
844 for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) {
845 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest);
851 // The range is too big. Emit "if" condition into a new block,
852 // making sure to save and restore the current insertion point.
853 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
855 // Push this test onto the chain of range checks (which terminates
856 // in the default basic block). The switch's default will be changed
857 // to the top of this chain after switch emission is complete.
858 llvm::BasicBlock *FalseDest = CaseRangeBlock;
859 CaseRangeBlock = createBasicBlock("sw.caserange");
861 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
862 Builder.SetInsertPoint(CaseRangeBlock);
866 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
868 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
869 Builder.CreateCondBr(Cond, CaseDest, FalseDest);
871 // Restore the appropriate insertion point.
873 Builder.SetInsertPoint(RestoreBB);
875 Builder.ClearInsertionPoint();
878 void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) {
879 // Handle case ranges.
881 EmitCaseStmtRange(S);
885 llvm::ConstantInt *CaseVal =
886 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
888 // If the body of the case is just a 'break', and if there was no fallthrough,
889 // try to not emit an empty block.
890 if (isa<BreakStmt>(S.getSubStmt())) {
891 JumpDest Block = BreakContinueStack.back().BreakBlock;
893 // Only do this optimization if there are no cleanups that need emitting.
894 if (isObviouslyBranchWithoutCleanups(Block)) {
895 SwitchInsn->addCase(CaseVal, Block.getBlock());
897 // If there was a fallthrough into this case, make sure to redirect it to
898 // the end of the switch as well.
899 if (Builder.GetInsertBlock()) {
900 Builder.CreateBr(Block.getBlock());
901 Builder.ClearInsertionPoint();
907 EmitBlock(createBasicBlock("sw.bb"));
908 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
909 SwitchInsn->addCase(CaseVal, CaseDest);
911 // Recursively emitting the statement is acceptable, but is not wonderful for
912 // code where we have many case statements nested together, i.e.:
916 // Handling this recursively will create a new block for each case statement
917 // that falls through to the next case which is IR intensive. It also causes
918 // deep recursion which can run into stack depth limitations. Handle
919 // sequential non-range case statements specially.
920 const CaseStmt *CurCase = &S;
921 const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt());
923 // Otherwise, iteratively add consecutive cases to this switch stmt.
924 while (NextCase && NextCase->getRHS() == 0) {
926 llvm::ConstantInt *CaseVal =
927 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
928 SwitchInsn->addCase(CaseVal, CaseDest);
929 NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt());
932 // Normal default recursion for non-cases.
933 EmitStmt(CurCase->getSubStmt());
936 void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {
937 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
938 assert(DefaultBlock->empty() &&
939 "EmitDefaultStmt: Default block already defined?");
940 EmitBlock(DefaultBlock);
941 EmitStmt(S.getSubStmt());
944 /// CollectStatementsForCase - Given the body of a 'switch' statement and a
945 /// constant value that is being switched on, see if we can dead code eliminate
946 /// the body of the switch to a simple series of statements to emit. Basically,
947 /// on a switch (5) we want to find these statements:
953 /// and add them to the ResultStmts vector. If it is unsafe to do this
954 /// transformation (for example, one of the elided statements contains a label
955 /// that might be jumped to), return CSFC_Failure. If we handled it and 'S'
956 /// should include statements after it (e.g. the printf() line is a substmt of
957 /// the case) then return CSFC_FallThrough. If we handled it and found a break
958 /// statement, then return CSFC_Success.
960 /// If Case is non-null, then we are looking for the specified case, checking
961 /// that nothing we jump over contains labels. If Case is null, then we found
962 /// the case and are looking for the break.
964 /// If the recursive walk actually finds our Case, then we set FoundCase to
967 enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success };
968 static CSFC_Result CollectStatementsForCase(const Stmt *S,
969 const SwitchCase *Case,
971 SmallVectorImpl<const Stmt*> &ResultStmts) {
972 // If this is a null statement, just succeed.
974 return Case ? CSFC_Success : CSFC_FallThrough;
976 // If this is the switchcase (case 4: or default) that we're looking for, then
977 // we're in business. Just add the substatement.
978 if (const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
981 return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase,
985 // Otherwise, this is some other case or default statement, just ignore it.
986 return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase,
990 // If we are in the live part of the code and we found our break statement,
992 if (Case == 0 && isa<BreakStmt>(S))
995 // If this is a switch statement, then it might contain the SwitchCase, the
996 // break, or neither.
997 if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
998 // Handle this as two cases: we might be looking for the SwitchCase (if so
999 // the skipped statements must be skippable) or we might already have it.
1000 CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end();
1002 // Keep track of whether we see a skipped declaration. The code could be
1003 // using the declaration even if it is skipped, so we can't optimize out
1004 // the decl if the kept statements might refer to it.
1005 bool HadSkippedDecl = false;
1007 // If we're looking for the case, just see if we can skip each of the
1009 for (; Case && I != E; ++I) {
1010 HadSkippedDecl |= isa<DeclStmt>(*I);
1012 switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) {
1013 case CSFC_Failure: return CSFC_Failure;
1015 // A successful result means that either 1) that the statement doesn't
1016 // have the case and is skippable, or 2) does contain the case value
1017 // and also contains the break to exit the switch. In the later case,
1018 // we just verify the rest of the statements are elidable.
1020 // If we found the case and skipped declarations, we can't do the
1023 return CSFC_Failure;
1025 for (++I; I != E; ++I)
1026 if (CodeGenFunction::ContainsLabel(*I, true))
1027 return CSFC_Failure;
1028 return CSFC_Success;
1031 case CSFC_FallThrough:
1032 // If we have a fallthrough condition, then we must have found the
1033 // case started to include statements. Consider the rest of the
1034 // statements in the compound statement as candidates for inclusion.
1035 assert(FoundCase && "Didn't find case but returned fallthrough?");
1036 // We recursively found Case, so we're not looking for it anymore.
1039 // If we found the case and skipped declarations, we can't do the
1042 return CSFC_Failure;
1048 // If we have statements in our range, then we know that the statements are
1049 // live and need to be added to the set of statements we're tracking.
1050 for (; I != E; ++I) {
1051 switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) {
1052 case CSFC_Failure: return CSFC_Failure;
1053 case CSFC_FallThrough:
1054 // A fallthrough result means that the statement was simple and just
1055 // included in ResultStmt, keep adding them afterwards.
1058 // A successful result means that we found the break statement and
1059 // stopped statement inclusion. We just ensure that any leftover stmts
1060 // are skippable and return success ourselves.
1061 for (++I; I != E; ++I)
1062 if (CodeGenFunction::ContainsLabel(*I, true))
1063 return CSFC_Failure;
1064 return CSFC_Success;
1068 return Case ? CSFC_Success : CSFC_FallThrough;
1071 // Okay, this is some other statement that we don't handle explicitly, like a
1072 // for statement or increment etc. If we are skipping over this statement,
1073 // just verify it doesn't have labels, which would make it invalid to elide.
1075 if (CodeGenFunction::ContainsLabel(S, true))
1076 return CSFC_Failure;
1077 return CSFC_Success;
1080 // Otherwise, we want to include this statement. Everything is cool with that
1081 // so long as it doesn't contain a break out of the switch we're in.
1082 if (CodeGenFunction::containsBreak(S)) return CSFC_Failure;
1084 // Otherwise, everything is great. Include the statement and tell the caller
1085 // that we fall through and include the next statement as well.
1086 ResultStmts.push_back(S);
1087 return CSFC_FallThrough;
1090 /// FindCaseStatementsForValue - Find the case statement being jumped to and
1091 /// then invoke CollectStatementsForCase to find the list of statements to emit
1092 /// for a switch on constant. See the comment above CollectStatementsForCase
1093 /// for more details.
1094 static bool FindCaseStatementsForValue(const SwitchStmt &S,
1095 const llvm::APInt &ConstantCondValue,
1096 SmallVectorImpl<const Stmt*> &ResultStmts,
1098 // First step, find the switch case that is being branched to. We can do this
1099 // efficiently by scanning the SwitchCase list.
1100 const SwitchCase *Case = S.getSwitchCaseList();
1101 const DefaultStmt *DefaultCase = 0;
1103 for (; Case; Case = Case->getNextSwitchCase()) {
1104 // It's either a default or case. Just remember the default statement in
1105 // case we're not jumping to any numbered cases.
1106 if (const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1111 // Check to see if this case is the one we're looking for.
1112 const CaseStmt *CS = cast<CaseStmt>(Case);
1113 // Don't handle case ranges yet.
1114 if (CS->getRHS()) return false;
1116 // If we found our case, remember it as 'case'.
1117 if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue)
1121 // If we didn't find a matching case, we use a default if it exists, or we
1122 // elide the whole switch body!
1124 // It is safe to elide the body of the switch if it doesn't contain labels
1125 // etc. If it is safe, return successfully with an empty ResultStmts list.
1126 if (DefaultCase == 0)
1127 return !CodeGenFunction::ContainsLabel(&S);
1131 // Ok, we know which case is being jumped to, try to collect all the
1132 // statements that follow it. This can fail for a variety of reasons. Also,
1133 // check to see that the recursive walk actually found our case statement.
1134 // Insane cases like this can fail to find it in the recursive walk since we
1135 // don't handle every stmt kind:
1139 bool FoundCase = false;
1140 return CollectStatementsForCase(S.getBody(), Case, FoundCase,
1141 ResultStmts) != CSFC_Failure &&
1145 void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) {
1146 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog");
1148 RunCleanupsScope ConditionScope(*this);
1150 if (S.getConditionVariable())
1151 EmitAutoVarDecl(*S.getConditionVariable());
1153 // See if we can constant fold the condition of the switch and therefore only
1154 // emit the live case statement (if any) of the switch.
1155 llvm::APInt ConstantCondValue;
1156 if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) {
1157 SmallVector<const Stmt*, 4> CaseStmts;
1158 if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts,
1160 RunCleanupsScope ExecutedScope(*this);
1162 // Okay, we can dead code eliminate everything except this case. Emit the
1163 // specified series of statements and we're good.
1164 for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1165 EmitStmt(CaseStmts[i]);
1170 llvm::Value *CondV = EmitScalarExpr(S.getCond());
1172 // Handle nested switch statements.
1173 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1174 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1176 // Create basic block to hold stuff that comes after switch
1177 // statement. We also need to create a default block now so that
1178 // explicit case ranges tests can have a place to jump to on
1180 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default");
1181 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
1182 CaseRangeBlock = DefaultBlock;
1184 // Clear the insertion point to indicate we are in unreachable code.
1185 Builder.ClearInsertionPoint();
1187 // All break statements jump to NextBlock. If BreakContinueStack is non empty
1188 // then reuse last ContinueBlock.
1189 JumpDest OuterContinue;
1190 if (!BreakContinueStack.empty())
1191 OuterContinue = BreakContinueStack.back().ContinueBlock;
1193 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
1195 // Emit switch body.
1196 EmitStmt(S.getBody());
1198 BreakContinueStack.pop_back();
1200 // Update the default block in case explicit case range tests have
1201 // been chained on top.
1202 SwitchInsn->setSuccessor(0, CaseRangeBlock);
1204 // If a default was never emitted:
1205 if (!DefaultBlock->getParent()) {
1206 // If we have cleanups, emit the default block so that there's a
1207 // place to jump through the cleanups from.
1208 if (ConditionScope.requiresCleanups()) {
1209 EmitBlock(DefaultBlock);
1211 // Otherwise, just forward the default block to the switch end.
1213 DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock());
1214 delete DefaultBlock;
1218 ConditionScope.ForceCleanup();
1220 // Emit continuation.
1221 EmitBlock(SwitchExit.getBlock(), true);
1223 SwitchInsn = SavedSwitchInsn;
1224 CaseRangeBlock = SavedCRBlock;
1228 SimplifyConstraint(const char *Constraint, const TargetInfo &Target,
1229 SmallVectorImpl<TargetInfo::ConstraintInfo> *OutCons=0) {
1232 while (*Constraint) {
1233 switch (*Constraint) {
1235 Result += Target.convertConstraint(Constraint);
1241 case '=': // Will see this and the following in mult-alt constraints.
1252 "Must pass output names to constraints with a symbolic name");
1254 bool result = Target.resolveSymbolicName(Constraint,
1256 OutCons->size(), Index);
1257 assert(result && "Could not resolve symbolic name"); (void)result;
1258 Result += llvm::utostr(Index);
1269 /// AddVariableConstraints - Look at AsmExpr and if it is a variable declared
1270 /// as using a particular register add that as a constraint that will be used
1271 /// in this asm stmt.
1273 AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
1274 const TargetInfo &Target, CodeGenModule &CGM,
1275 const AsmStmt &Stmt) {
1276 const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);
1279 const ValueDecl &Value = *AsmDeclRef->getDecl();
1280 const VarDecl *Variable = dyn_cast<VarDecl>(&Value);
1283 AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>();
1286 StringRef Register = Attr->getLabel();
1287 assert(Target.isValidGCCRegisterName(Register));
1288 // We're using validateOutputConstraint here because we only care if
1289 // this is a register constraint.
1290 TargetInfo::ConstraintInfo Info(Constraint, "");
1291 if (Target.validateOutputConstraint(Info) &&
1292 !Info.allowsRegister()) {
1293 CGM.ErrorUnsupported(&Stmt, "__asm__");
1296 // Canonicalize the register here before returning it.
1297 Register = Target.getNormalizedGCCRegisterName(Register);
1298 return "{" + Register.str() + "}";
1302 CodeGenFunction::EmitAsmInputLValue(const AsmStmt &S,
1303 const TargetInfo::ConstraintInfo &Info,
1304 LValue InputValue, QualType InputType,
1305 std::string &ConstraintStr) {
1307 if (Info.allowsRegister() || !Info.allowsMemory()) {
1308 if (!CodeGenFunction::hasAggregateLLVMType(InputType)) {
1309 Arg = EmitLoadOfLValue(InputValue).getScalarVal();
1311 llvm::Type *Ty = ConvertType(InputType);
1312 uint64_t Size = CGM.getTargetData().getTypeSizeInBits(Ty);
1313 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
1314 Ty = llvm::IntegerType::get(getLLVMContext(), Size);
1315 Ty = llvm::PointerType::getUnqual(Ty);
1317 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1320 Arg = InputValue.getAddress();
1321 ConstraintStr += '*';
1325 Arg = InputValue.getAddress();
1326 ConstraintStr += '*';
1332 llvm::Value* CodeGenFunction::EmitAsmInput(const AsmStmt &S,
1333 const TargetInfo::ConstraintInfo &Info,
1334 const Expr *InputExpr,
1335 std::string &ConstraintStr) {
1336 if (Info.allowsRegister() || !Info.allowsMemory())
1337 if (!CodeGenFunction::hasAggregateLLVMType(InputExpr->getType()))
1338 return EmitScalarExpr(InputExpr);
1340 InputExpr = InputExpr->IgnoreParenNoopCasts(getContext());
1341 LValue Dest = EmitLValue(InputExpr);
1342 return EmitAsmInputLValue(S, Info, Dest, InputExpr->getType(), ConstraintStr);
1345 /// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline
1346 /// asm call instruction. The !srcloc MDNode contains a list of constant
1347 /// integers which are the source locations of the start of each line in the
1349 static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
1350 CodeGenFunction &CGF) {
1351 SmallVector<llvm::Value *, 8> Locs;
1352 // Add the location of the first line to the MDNode.
1353 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1354 Str->getLocStart().getRawEncoding()));
1355 StringRef StrVal = Str->getString();
1356 if (!StrVal.empty()) {
1357 const SourceManager &SM = CGF.CGM.getContext().getSourceManager();
1358 const LangOptions &LangOpts = CGF.CGM.getLangOptions();
1360 // Add the location of the start of each subsequent line of the asm to the
1362 for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) {
1363 if (StrVal[i] != '\n') continue;
1364 SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts,
1366 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1367 LineLoc.getRawEncoding()));
1371 return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
1374 void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
1375 // Analyze the asm string to decompose it into its pieces. We know that Sema
1376 // has already done this, so it is guaranteed to be successful.
1377 SmallVector<AsmStmt::AsmStringPiece, 4> Pieces;
1379 S.AnalyzeAsmString(Pieces, getContext(), DiagOffs);
1381 // Assemble the pieces into the final asm string.
1382 std::string AsmString;
1383 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
1384 if (Pieces[i].isString())
1385 AsmString += Pieces[i].getString();
1386 else if (Pieces[i].getModifier() == '\0')
1387 AsmString += '$' + llvm::utostr(Pieces[i].getOperandNo());
1389 AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' +
1390 Pieces[i].getModifier() + '}';
1393 // Get all the output and input constraints together.
1394 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1395 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1397 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
1398 TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i),
1399 S.getOutputName(i));
1400 bool IsValid = Target.validateOutputConstraint(Info); (void)IsValid;
1401 assert(IsValid && "Failed to parse output constraint");
1402 OutputConstraintInfos.push_back(Info);
1405 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1406 TargetInfo::ConstraintInfo Info(S.getInputConstraint(i),
1408 bool IsValid = Target.validateInputConstraint(OutputConstraintInfos.data(),
1409 S.getNumOutputs(), Info);
1410 assert(IsValid && "Failed to parse input constraint"); (void)IsValid;
1411 InputConstraintInfos.push_back(Info);
1414 std::string Constraints;
1416 std::vector<LValue> ResultRegDests;
1417 std::vector<QualType> ResultRegQualTys;
1418 std::vector<llvm::Type *> ResultRegTypes;
1419 std::vector<llvm::Type *> ResultTruncRegTypes;
1420 std::vector<llvm::Type*> ArgTypes;
1421 std::vector<llvm::Value*> Args;
1423 // Keep track of inout constraints.
1424 std::string InOutConstraints;
1425 std::vector<llvm::Value*> InOutArgs;
1426 std::vector<llvm::Type*> InOutArgTypes;
1428 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
1429 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
1431 // Simplify the output constraint.
1432 std::string OutputConstraint(S.getOutputConstraint(i));
1433 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, Target);
1435 const Expr *OutExpr = S.getOutputExpr(i);
1436 OutExpr = OutExpr->IgnoreParenNoopCasts(getContext());
1438 OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr,
1441 LValue Dest = EmitLValue(OutExpr);
1442 if (!Constraints.empty())
1445 // If this is a register output, then make the inline asm return it
1446 // by-value. If this is a memory result, return the value by-reference.
1447 if (!Info.allowsMemory() && !hasAggregateLLVMType(OutExpr->getType())) {
1448 Constraints += "=" + OutputConstraint;
1449 ResultRegQualTys.push_back(OutExpr->getType());
1450 ResultRegDests.push_back(Dest);
1451 ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType()));
1452 ResultTruncRegTypes.push_back(ResultRegTypes.back());
1454 // If this output is tied to an input, and if the input is larger, then
1455 // we need to set the actual result type of the inline asm node to be the
1456 // same as the input type.
1457 if (Info.hasMatchingInput()) {
1459 for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) {
1460 TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo];
1461 if (Input.hasTiedOperand() && Input.getTiedOperand() == i)
1464 assert(InputNo != S.getNumInputs() && "Didn't find matching input!");
1466 QualType InputTy = S.getInputExpr(InputNo)->getType();
1467 QualType OutputType = OutExpr->getType();
1469 uint64_t InputSize = getContext().getTypeSize(InputTy);
1470 if (getContext().getTypeSize(OutputType) < InputSize) {
1471 // Form the asm to return the value as a larger integer or fp type.
1472 ResultRegTypes.back() = ConvertType(InputTy);
1475 if (llvm::Type* AdjTy =
1476 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1477 ResultRegTypes.back()))
1478 ResultRegTypes.back() = AdjTy;
1480 ArgTypes.push_back(Dest.getAddress()->getType());
1481 Args.push_back(Dest.getAddress());
1482 Constraints += "=*";
1483 Constraints += OutputConstraint;
1486 if (Info.isReadWrite()) {
1487 InOutConstraints += ',';
1489 const Expr *InputExpr = S.getOutputExpr(i);
1490 llvm::Value *Arg = EmitAsmInputLValue(S, Info, Dest, InputExpr->getType(),
1493 if (Info.allowsRegister())
1494 InOutConstraints += llvm::utostr(i);
1496 InOutConstraints += OutputConstraint;
1498 InOutArgTypes.push_back(Arg->getType());
1499 InOutArgs.push_back(Arg);
1503 unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs();
1505 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1506 const Expr *InputExpr = S.getInputExpr(i);
1508 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1510 if (!Constraints.empty())
1513 // Simplify the input constraint.
1514 std::string InputConstraint(S.getInputConstraint(i));
1515 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), Target,
1516 &OutputConstraintInfos);
1519 AddVariableConstraints(InputConstraint,
1520 *InputExpr->IgnoreParenNoopCasts(getContext()),
1523 llvm::Value *Arg = EmitAsmInput(S, Info, InputExpr, Constraints);
1525 // If this input argument is tied to a larger output result, extend the
1526 // input to be the same size as the output. The LLVM backend wants to see
1527 // the input and output of a matching constraint be the same size. Note
1528 // that GCC does not define what the top bits are here. We use zext because
1529 // that is usually cheaper, but LLVM IR should really get an anyext someday.
1530 if (Info.hasTiedOperand()) {
1531 unsigned Output = Info.getTiedOperand();
1532 QualType OutputType = S.getOutputExpr(Output)->getType();
1533 QualType InputTy = InputExpr->getType();
1535 if (getContext().getTypeSize(OutputType) >
1536 getContext().getTypeSize(InputTy)) {
1537 // Use ptrtoint as appropriate so that we can do our extension.
1538 if (isa<llvm::PointerType>(Arg->getType()))
1539 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy);
1540 llvm::Type *OutputTy = ConvertType(OutputType);
1541 if (isa<llvm::IntegerType>(OutputTy))
1542 Arg = Builder.CreateZExt(Arg, OutputTy);
1543 else if (isa<llvm::PointerType>(OutputTy))
1544 Arg = Builder.CreateZExt(Arg, IntPtrTy);
1546 assert(OutputTy->isFloatingPointTy() && "Unexpected output type");
1547 Arg = Builder.CreateFPExt(Arg, OutputTy);
1551 if (llvm::Type* AdjTy =
1552 getTargetHooks().adjustInlineAsmType(*this, InputConstraint,
1554 Arg = Builder.CreateBitCast(Arg, AdjTy);
1556 ArgTypes.push_back(Arg->getType());
1557 Args.push_back(Arg);
1558 Constraints += InputConstraint;
1561 // Append the "input" part of inout constraints last.
1562 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
1563 ArgTypes.push_back(InOutArgTypes[i]);
1564 Args.push_back(InOutArgs[i]);
1566 Constraints += InOutConstraints;
1569 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
1570 StringRef Clobber = S.getClobber(i)->getString();
1572 if (Clobber != "memory" && Clobber != "cc")
1573 Clobber = Target.getNormalizedGCCRegisterName(Clobber);
1575 if (i != 0 || NumConstraints != 0)
1578 Constraints += "~{";
1579 Constraints += Clobber;
1583 // Add machine specific clobbers
1584 std::string MachineClobbers = Target.getClobbers();
1585 if (!MachineClobbers.empty()) {
1586 if (!Constraints.empty())
1588 Constraints += MachineClobbers;
1591 llvm::Type *ResultType;
1592 if (ResultRegTypes.empty())
1593 ResultType = llvm::Type::getVoidTy(getLLVMContext());
1594 else if (ResultRegTypes.size() == 1)
1595 ResultType = ResultRegTypes[0];
1597 ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes);
1599 llvm::FunctionType *FTy =
1600 llvm::FunctionType::get(ResultType, ArgTypes, false);
1602 llvm::InlineAsm *IA =
1603 llvm::InlineAsm::get(FTy, AsmString, Constraints,
1604 S.isVolatile() || S.getNumOutputs() == 0);
1605 llvm::CallInst *Result = Builder.CreateCall(IA, Args);
1606 Result->addAttribute(~0, llvm::Attribute::NoUnwind);
1608 // Slap the source location of the inline asm into a !srcloc metadata on the
1610 Result->setMetadata("srcloc", getAsmSrcLocInfo(S.getAsmString(), *this));
1612 // Extract all of the register value results from the asm.
1613 std::vector<llvm::Value*> RegResults;
1614 if (ResultRegTypes.size() == 1) {
1615 RegResults.push_back(Result);
1617 for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
1618 llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult");
1619 RegResults.push_back(Tmp);
1623 for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {
1624 llvm::Value *Tmp = RegResults[i];
1626 // If the result type of the LLVM IR asm doesn't match the result type of
1627 // the expression, do the conversion.
1628 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
1629 llvm::Type *TruncTy = ResultTruncRegTypes[i];
1631 // Truncate the integer result to the right size, note that TruncTy can be
1633 if (TruncTy->isFloatingPointTy())
1634 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy);
1635 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
1636 uint64_t ResSize = CGM.getTargetData().getTypeSizeInBits(TruncTy);
1637 Tmp = Builder.CreateTrunc(Tmp,
1638 llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize));
1639 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy);
1640 } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
1641 uint64_t TmpSize =CGM.getTargetData().getTypeSizeInBits(Tmp->getType());
1642 Tmp = Builder.CreatePtrToInt(Tmp,
1643 llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize));
1644 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
1645 } else if (TruncTy->isIntegerTy()) {
1646 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
1647 } else if (TruncTy->isVectorTy()) {
1648 Tmp = Builder.CreateBitCast(Tmp, TruncTy);
1652 EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]);