blob: 80a8da76cc52334d03e28f1781738f6bbad9afc4 [file] [log] [blame]
Chris Lattnere47e4402007-06-01 18:02:12 +00001//===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnere47e4402007-06-01 18:02:12 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Stmt nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "CodeGenFunction.h"
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000015#include "CGDebugInfo.h"
16#include "CodeGenModule.h"
Peter Collingbourne8f5cf742011-02-19 23:03:58 +000017#include "TargetInfo.h"
Daniel Dunbarad319a72008-08-11 05:00:27 +000018#include "clang/AST/StmtVisitor.h"
Chris Lattnerff9fbca2009-03-05 08:04:57 +000019#include "clang/Basic/PrettyStackTrace.h"
Anders Carlsson952a9952008-02-05 16:35:33 +000020#include "clang/Basic/TargetInfo.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000021#include "clang/Sema/SemaDiagnostic.h"
Anders Carlsson952a9952008-02-05 16:35:33 +000022#include "llvm/ADT/StringExtras.h"
Chandler Carruthc80ceea2014-03-04 11:02:08 +000023#include "llvm/IR/CallSite.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000024#include "llvm/IR/DataLayout.h"
25#include "llvm/IR/InlineAsm.h"
26#include "llvm/IR/Intrinsics.h"
Chris Lattnere47e4402007-06-01 18:02:12 +000027using namespace clang;
28using namespace CodeGen;
29
30//===----------------------------------------------------------------------===//
31// Statement Emission
32//===----------------------------------------------------------------------===//
33
Daniel Dunbar5fc28712008-11-12 08:21:33 +000034void CodeGenFunction::EmitStopPoint(const Stmt *S) {
Anders Carlsson63784f42009-02-13 08:11:52 +000035 if (CGDebugInfo *DI = getDebugInfo()) {
Eric Christopher7cdf9482011-10-13 21:45:18 +000036 SourceLocation Loc;
Adrian Prantlde5fde02013-06-18 00:27:36 +000037 Loc = S->getLocStart();
Eric Christopher7cdf9482011-10-13 21:45:18 +000038 DI->EmitLocation(Builder, Loc);
Adrian Prantl3be10542013-05-02 17:30:20 +000039
Adrian Prantle83b1302014-01-07 22:05:52 +000040 LastStopPoint = Loc;
Daniel Dunbar5fc28712008-11-12 08:21:33 +000041 }
42}
43
Chris Lattnere47e4402007-06-01 18:02:12 +000044void CodeGenFunction::EmitStmt(const Stmt *S) {
45 assert(S && "Null statement?");
Bob Wilsonbf854f02014-02-17 19:21:09 +000046 PGO.setCurrentStmt(S);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +000047
Eric Christopher22e15702011-09-26 15:03:19 +000048 // These statements have their own debug info handling.
Daniel Dunbar5fc28712008-11-12 08:21:33 +000049 if (EmitSimpleStmt(S))
50 return;
51
Daniel Dunbarb6adc432009-07-19 06:58:07 +000052 // Check if we are generating unreachable code.
53 if (!HaveInsertPoint()) {
54 // If so, and the statement doesn't contain a label, then we do not need to
55 // generate actual code. This is safe because (1) the current point is
56 // unreachable, so we don't need to execute the code, and (2) we've already
57 // handled the statements which update internal data structures (like the
58 // local variable map) which could be used by subsequent statements.
59 if (!ContainsLabel(S)) {
60 // Verify that any decl statements were handled as simple, they may be in
61 // scope of subsequent reachable statements.
62 assert(!isa<DeclStmt>(*S) && "Unexpected DeclStmt!");
63 return;
64 }
65
66 // Otherwise, make a new block to hold the code.
67 EnsureInsertPoint();
68 }
69
Daniel Dunbar5fc28712008-11-12 08:21:33 +000070 // Generate a stoppoint if we are emitting debug info.
71 EmitStopPoint(S);
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000072
Chris Lattnere47e4402007-06-01 18:02:12 +000073 switch (S->getStmtClass()) {
John McCalla2342eb2010-12-05 02:00:02 +000074 case Stmt::NoStmtClass:
75 case Stmt::CXXCatchStmtClass:
John Wiegley1c0675e2011-04-28 01:08:34 +000076 case Stmt::SEHExceptStmtClass:
77 case Stmt::SEHFinallyStmtClass:
Douglas Gregordeb4a2be2011-10-25 01:33:02 +000078 case Stmt::MSDependentExistsStmtClass:
Alexey Bataev5ec3eb12013-07-19 03:13:43 +000079 case Stmt::OMPParallelDirectiveClass:
Alexey Bataev1b59ab52014-02-27 08:29:12 +000080 case Stmt::OMPSimdDirectiveClass:
John McCalla2342eb2010-12-05 02:00:02 +000081 llvm_unreachable("invalid statement class to emit generically");
82 case Stmt::NullStmtClass:
83 case Stmt::CompoundStmtClass:
84 case Stmt::DeclStmtClass:
85 case Stmt::LabelStmtClass:
Richard Smithc202b282012-04-14 00:33:13 +000086 case Stmt::AttributedStmtClass:
John McCalla2342eb2010-12-05 02:00:02 +000087 case Stmt::GotoStmtClass:
88 case Stmt::BreakStmtClass:
89 case Stmt::ContinueStmtClass:
90 case Stmt::DefaultStmtClass:
91 case Stmt::CaseStmtClass:
92 llvm_unreachable("should have emitted these statements as simple");
Daniel Dunbarc3ab4c62009-07-19 08:23:12 +000093
John McCalla2342eb2010-12-05 02:00:02 +000094#define STMT(Type, Base)
95#define ABSTRACT_STMT(Op)
96#define EXPR(Type, Base) \
97 case Stmt::Type##Class:
98#include "clang/AST/StmtNodes.inc"
John McCall20f6ab82011-01-12 03:41:02 +000099 {
100 // Remember the block we came in on.
101 llvm::BasicBlock *incoming = Builder.GetInsertBlock();
102 assert(incoming && "expression emission must have an insertion point");
103
John McCalla2342eb2010-12-05 02:00:02 +0000104 EmitIgnoredExpr(cast<Expr>(S));
Mike Stump11289f42009-09-09 15:08:12 +0000105
John McCall20f6ab82011-01-12 03:41:02 +0000106 llvm::BasicBlock *outgoing = Builder.GetInsertBlock();
107 assert(outgoing && "expression emission cleared block!");
108
109 // The expression emitters assume (reasonably!) that the insertion
110 // point is always set. To maintain that, the call-emission code
111 // for noreturn functions has to enter a new block with no
112 // predecessors. We want to kill that block and mark the current
113 // insertion point unreachable in the common case of a call like
114 // "exit();". Since expression emission doesn't otherwise create
115 // blocks with no predecessors, we can just test for that.
116 // However, we must be careful not to do this to our incoming
117 // block, because *statement* emission does sometimes create
118 // reachable blocks which will have no predecessors until later in
119 // the function. This occurs with, e.g., labels that are not
120 // reachable by fallthrough.
121 if (incoming != outgoing && outgoing->use_empty()) {
122 outgoing->eraseFromParent();
123 Builder.ClearInsertionPoint();
Chris Lattnere47e4402007-06-01 18:02:12 +0000124 }
125 break;
John McCall20f6ab82011-01-12 03:41:02 +0000126 }
John McCalla2342eb2010-12-05 02:00:02 +0000127
Mike Stump11289f42009-09-09 15:08:12 +0000128 case Stmt::IndirectGotoStmtClass:
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000129 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break;
Chris Lattner946aa312007-06-05 03:59:43 +0000130
Chris Lattnere47e4402007-06-01 18:02:12 +0000131 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break;
Chris Lattner946aa312007-06-05 03:59:43 +0000132 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break;
Chris Lattner8394d792007-06-05 20:53:16 +0000133 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break;
134 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break;
Mike Stump11289f42009-09-09 15:08:12 +0000135
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000136 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break;
Daniel Dunbare23f28f2008-10-02 18:02:06 +0000137
Devang Patelda5d6bb2007-10-04 23:45:31 +0000138 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break;
Chad Rosier649dfc32012-08-28 21:11:24 +0000139 case Stmt::GCCAsmStmtClass: // Intentional fall-through.
140 case Stmt::MSAsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break;
Alexey Bataev758e55e2013-09-06 18:03:48 +0000141 case Stmt::CapturedStmtClass: {
142 const CapturedStmt *CS = cast<CapturedStmt>(S);
143 EmitCapturedStmt(*CS, CS->getCapturedRegionKind());
144 }
Tareq A. Siraj24110cc2013-04-16 18:53:08 +0000145 break;
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000146 case Stmt::ObjCAtTryStmtClass:
Anders Carlsson1963b0c2008-09-09 10:04:29 +0000147 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
Mike Stump11289f42009-09-09 15:08:12 +0000148 break;
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000149 case Stmt::ObjCAtCatchStmtClass:
David Blaikie83d382b2011-09-23 05:06:16 +0000150 llvm_unreachable(
151 "@catch statements should be handled by EmitObjCAtTryStmt");
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000152 case Stmt::ObjCAtFinallyStmtClass:
David Blaikie83d382b2011-09-23 05:06:16 +0000153 llvm_unreachable(
154 "@finally statements should be handled by EmitObjCAtTryStmt");
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000155 case Stmt::ObjCAtThrowStmtClass:
Anders Carlsson1963b0c2008-09-09 10:04:29 +0000156 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000157 break;
158 case Stmt::ObjCAtSynchronizedStmtClass:
Chris Lattnere132e242008-11-15 21:26:17 +0000159 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S));
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000160 break;
Mike Stump11289f42009-09-09 15:08:12 +0000161 case Stmt::ObjCForCollectionStmtClass:
Anders Carlsson2e744e82008-08-30 19:51:14 +0000162 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000163 break;
John McCall31168b02011-06-15 23:02:42 +0000164 case Stmt::ObjCAutoreleasePoolStmtClass:
165 EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S));
166 break;
Chad Rosierbebf1462012-06-20 17:43:05 +0000167
Anders Carlsson52d78a52009-09-27 18:58:34 +0000168 case Stmt::CXXTryStmtClass:
169 EmitCXXTryStmt(cast<CXXTryStmt>(*S));
170 break;
Richard Smith02e85f32011-04-14 22:09:26 +0000171 case Stmt::CXXForRangeStmtClass:
172 EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S));
Reid Kleckner543a16c2013-09-16 21:46:30 +0000173 break;
John Wiegley1c0675e2011-04-28 01:08:34 +0000174 case Stmt::SEHTryStmtClass:
Reid Kleckner543a16c2013-09-16 21:46:30 +0000175 EmitSEHTryStmt(cast<SEHTryStmt>(*S));
Richard Smith02e85f32011-04-14 22:09:26 +0000176 break;
Chris Lattnere47e4402007-06-01 18:02:12 +0000177 }
178}
179
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000180bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
181 switch (S->getStmtClass()) {
182 default: return false;
183 case Stmt::NullStmtClass: break;
184 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
Daniel Dunbarb6adc432009-07-19 06:58:07 +0000185 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break;
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000186 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break;
Richard Smithc202b282012-04-14 00:33:13 +0000187 case Stmt::AttributedStmtClass:
188 EmitAttributedStmt(cast<AttributedStmt>(*S)); break;
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000189 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break;
190 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break;
191 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break;
192 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break;
193 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break;
194 }
195
196 return true;
197}
198
Chris Lattner04a913b2007-08-31 22:09:40 +0000199/// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true,
200/// this captures the expression result of the last sub-statement and returns it
201/// (for use by the statement expression extension).
Eli Friedman4871a462013-06-10 22:04:49 +0000202llvm::Value* CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
203 AggValueSlot AggSlot) {
Chris Lattnerff9fbca2009-03-05 08:04:57 +0000204 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(),
205 "LLVM IR generation of compound statement ('{}')");
Mike Stump11289f42009-09-09 15:08:12 +0000206
Eric Christopher27bc9fe2012-02-23 00:43:07 +0000207 // Keep track of the current cleanup stack depth, including debug scopes.
208 LexicalScope Scope(*this, S.getSourceRange());
Mike Stump11289f42009-09-09 15:08:12 +0000209
David Blaikie0a21d0d2013-01-26 22:16:26 +0000210 return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot);
211}
212
Eli Friedman4871a462013-06-10 22:04:49 +0000213llvm::Value*
214CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S,
215 bool GetLast,
216 AggValueSlot AggSlot) {
David Blaikie0a21d0d2013-01-26 22:16:26 +0000217
Chris Lattner04a913b2007-08-31 22:09:40 +0000218 for (CompoundStmt::const_body_iterator I = S.body_begin(),
219 E = S.body_end()-GetLast; I != E; ++I)
Chris Lattnere47e4402007-06-01 18:02:12 +0000220 EmitStmt(*I);
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000221
Eli Friedman4871a462013-06-10 22:04:49 +0000222 llvm::Value *RetAlloca = 0;
223 if (GetLast) {
Mike Stump11289f42009-09-09 15:08:12 +0000224 // We have to special case labels here. They are statements, but when put
Anders Carlsson8a472c32008-12-12 05:52:00 +0000225 // at the end of a statement expression, they yield the value of their
226 // subexpression. Handle this by walking through all labels we encounter,
227 // emitting them before we evaluate the subexpr.
228 const Stmt *LastStmt = S.body_back();
229 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000230 EmitLabel(LS->getDecl());
Anders Carlsson8a472c32008-12-12 05:52:00 +0000231 LastStmt = LS->getSubStmt();
232 }
Mike Stump11289f42009-09-09 15:08:12 +0000233
Anders Carlsson8a472c32008-12-12 05:52:00 +0000234 EnsureInsertPoint();
Mike Stump11289f42009-09-09 15:08:12 +0000235
Eli Friedman4871a462013-06-10 22:04:49 +0000236 QualType ExprTy = cast<Expr>(LastStmt)->getType();
237 if (hasAggregateEvaluationKind(ExprTy)) {
238 EmitAggExpr(cast<Expr>(LastStmt), AggSlot);
239 } else {
240 // We can't return an RValue here because there might be cleanups at
241 // the end of the StmtExpr. Because of that, we have to emit the result
242 // here into a temporary alloca.
243 RetAlloca = CreateMemTemp(ExprTy);
244 EmitAnyExprToMem(cast<Expr>(LastStmt), RetAlloca, Qualifiers(),
245 /*IsInit*/false);
246 }
Justin Bogner0f066062013-11-22 10:20:40 +0000247
Anders Carlsson8a472c32008-12-12 05:52:00 +0000248 }
249
Eli Friedman4871a462013-06-10 22:04:49 +0000250 return RetAlloca;
Chris Lattnere47e4402007-06-01 18:02:12 +0000251}
252
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000253void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) {
254 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
Mike Stump11289f42009-09-09 15:08:12 +0000255
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000256 // If there is a cleanup stack, then we it isn't worth trying to
257 // simplify this block (we would need to remove it from the scope map
258 // and cleanup entry).
John McCallbd309292010-07-06 01:34:17 +0000259 if (!EHStack.empty())
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000260 return;
261
262 // Can only simplify direct branches.
263 if (!BI || !BI->isUnconditional())
264 return;
265
Eli Friedmanfc5b2ef2012-10-26 23:23:35 +0000266 // Can only simplify empty blocks.
267 if (BI != BB->begin())
268 return;
269
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000270 BB->replaceAllUsesWith(BI->getSuccessor(0));
271 BI->eraseFromParent();
272 BB->eraseFromParent();
273}
274
Daniel Dunbarfcac22e2008-11-13 01:24:05 +0000275void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) {
John McCallbf814c72010-04-21 11:18:06 +0000276 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
277
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000278 // Fall out of the current block (if necessary).
279 EmitBranch(BB);
Daniel Dunbarfcac22e2008-11-13 01:24:05 +0000280
281 if (IsFinished && BB->use_empty()) {
282 delete BB;
283 return;
284 }
285
John McCalle6833592010-04-21 10:29:06 +0000286 // Place the block after the current block, if possible, or else at
287 // the end of the function.
John McCallbf814c72010-04-21 11:18:06 +0000288 if (CurBB && CurBB->getParent())
289 CurFn->getBasicBlockList().insertAfter(CurBB, BB);
John McCalle6833592010-04-21 10:29:06 +0000290 else
291 CurFn->getBasicBlockList().push_back(BB);
Chris Lattnere47e4402007-06-01 18:02:12 +0000292 Builder.SetInsertPoint(BB);
293}
294
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000295void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) {
296 // Emit a branch from the current block to the target one if this
297 // was a real block. If this was just a fall-through block after a
298 // terminator, don't emit it.
299 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
300
301 if (!CurBB || CurBB->getTerminator()) {
302 // If there is no insert point or the previous block is already
303 // terminated, don't touch it.
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000304 } else {
305 // Otherwise, create a fall-through branch.
306 Builder.CreateBr(Target);
307 }
Daniel Dunbarab197eb2008-11-11 22:06:59 +0000308
309 Builder.ClearInsertionPoint();
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000310}
311
John McCall8e4c74b2011-08-11 02:22:43 +0000312void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) {
313 bool inserted = false;
314 for (llvm::BasicBlock::use_iterator
315 i = block->use_begin(), e = block->use_end(); i != e; ++i) {
316 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(*i)) {
317 CurFn->getBasicBlockList().insertAfter(insn->getParent(), block);
318 inserted = true;
319 break;
320 }
321 }
322
323 if (!inserted)
324 CurFn->getBasicBlockList().push_back(block);
325
326 Builder.SetInsertPoint(block);
327}
328
John McCallbd309292010-07-06 01:34:17 +0000329CodeGenFunction::JumpDest
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000330CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) {
331 JumpDest &Dest = LabelMap[D];
John McCallad5d61e2010-07-23 21:56:41 +0000332 if (Dest.isValid()) return Dest;
John McCallbd309292010-07-06 01:34:17 +0000333
334 // Create, but don't insert, the new block.
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000335 Dest = JumpDest(createBasicBlock(D->getName()),
John McCallad5d61e2010-07-23 21:56:41 +0000336 EHScopeStack::stable_iterator::invalid(),
337 NextCleanupDestIndex++);
John McCallbd309292010-07-06 01:34:17 +0000338 return Dest;
339}
340
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000341void CodeGenFunction::EmitLabel(const LabelDecl *D) {
Nadav Rotem1da30942013-03-23 06:43:35 +0000342 // Add this label to the current lexical scope if we're within any
343 // normal cleanups. Jumps "in" to this label --- when permitted by
344 // the language --- may need to be routed around such cleanups.
345 if (EHStack.hasNormalCleanups() && CurLexicalScope)
346 CurLexicalScope->addLabel(D);
347
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000348 JumpDest &Dest = LabelMap[D];
John McCallbd309292010-07-06 01:34:17 +0000349
John McCallad5d61e2010-07-23 21:56:41 +0000350 // If we didn't need a forward reference to this label, just go
John McCallbd309292010-07-06 01:34:17 +0000351 // ahead and create a destination at the current scope.
John McCallad5d61e2010-07-23 21:56:41 +0000352 if (!Dest.isValid()) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000353 Dest = getJumpDestInCurrentScope(D->getName());
John McCallbd309292010-07-06 01:34:17 +0000354
355 // Otherwise, we need to give this label a target depth and remove
356 // it from the branch-fixups list.
357 } else {
John McCallad5d61e2010-07-23 21:56:41 +0000358 assert(!Dest.getScopeDepth().isValid() && "already emitted label!");
Nadav Rotem1da30942013-03-23 06:43:35 +0000359 Dest.setScopeDepth(EHStack.stable_begin());
John McCallad5d61e2010-07-23 21:56:41 +0000360 ResolveBranchFixups(Dest.getBlock());
John McCallbd309292010-07-06 01:34:17 +0000361 }
362
Justin Bogneref512b92014-01-06 22:27:43 +0000363 RegionCounter Cnt = getPGORegionCounter(D->getStmt());
John McCallad5d61e2010-07-23 21:56:41 +0000364 EmitBlock(Dest.getBlock());
Justin Bogneref512b92014-01-06 22:27:43 +0000365 Cnt.beginRegion(Builder);
Chris Lattner7e800972008-07-26 20:23:23 +0000366}
367
Nadav Rotem1da30942013-03-23 06:43:35 +0000368/// Change the cleanup scope of the labels in this lexical scope to
369/// match the scope of the enclosing context.
370void CodeGenFunction::LexicalScope::rescopeLabels() {
371 assert(!Labels.empty());
372 EHScopeStack::stable_iterator innermostScope
373 = CGF.EHStack.getInnermostNormalCleanup();
374
375 // Change the scope depth of all the labels.
376 for (SmallVectorImpl<const LabelDecl*>::const_iterator
377 i = Labels.begin(), e = Labels.end(); i != e; ++i) {
378 assert(CGF.LabelMap.count(*i));
379 JumpDest &dest = CGF.LabelMap.find(*i)->second;
380 assert(dest.getScopeDepth().isValid());
381 assert(innermostScope.encloses(dest.getScopeDepth()));
382 dest.setScopeDepth(innermostScope);
383 }
384
385 // Reparent the labels if the new scope also has cleanups.
386 if (innermostScope != EHScopeStack::stable_end() && ParentScope) {
387 ParentScope->Labels.append(Labels.begin(), Labels.end());
388 }
389}
390
Chris Lattner7e800972008-07-26 20:23:23 +0000391
392void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000393 EmitLabel(S.getDecl());
Chris Lattnere47e4402007-06-01 18:02:12 +0000394 EmitStmt(S.getSubStmt());
395}
396
Richard Smithc202b282012-04-14 00:33:13 +0000397void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) {
398 EmitStmt(S.getSubStmt());
399}
400
Chris Lattnere47e4402007-06-01 18:02:12 +0000401void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000402 // If this code is reachable then emit a stop point (if generating
403 // debug info). We have to do this ourselves because we are on the
404 // "simple" statement path.
405 if (HaveInsertPoint())
406 EmitStopPoint(&S);
Mike Stump1d91dd92009-02-07 12:52:26 +0000407
John McCallbd309292010-07-06 01:34:17 +0000408 EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel()));
Chris Lattnere47e4402007-06-01 18:02:12 +0000409}
410
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000411
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000412void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000413 if (const LabelDecl *Target = S.getConstantTarget()) {
John McCall9de91602010-10-28 08:53:48 +0000414 EmitBranchThroughCleanup(getJumpDestForLabel(Target));
415 return;
416 }
417
Chris Lattner353fc1e42009-11-06 18:10:47 +0000418 // Ensure that we have an i8* for our PHI node.
Chris Lattner6c4d2552009-10-28 23:59:40 +0000419 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
John McCallad7c5c12011-02-08 08:22:06 +0000420 Int8PtrTy, "addr");
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000421 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000422
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000423 // Get the basic block for the indirect goto.
424 llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock();
Chad Rosierbebf1462012-06-20 17:43:05 +0000425
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000426 // The first instruction in the block has to be the PHI for the switch dest,
427 // add an entry for this branch.
428 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
Chad Rosierbebf1462012-06-20 17:43:05 +0000429
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000430 EmitBranch(IndGotoBB);
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000431}
432
Chris Lattneraaaa1992008-11-11 07:24:28 +0000433void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
Chris Lattnere47e4402007-06-01 18:02:12 +0000434 // C99 6.8.4.1: The first substatement is executed if the expression compares
435 // unequal to 0. The condition must be a scalar type.
Eric Christopher872018b2013-07-10 20:14:36 +0000436 LexicalScope ConditionScope(*this, S.getSourceRange());
Justin Bogneref512b92014-01-06 22:27:43 +0000437 RegionCounter Cnt = getPGORegionCounter(&S);
Adrian Prantl0ffce6e2013-06-08 00:16:55 +0000438
Douglas Gregor633caca2009-11-23 23:44:04 +0000439 if (S.getConditionVariable())
John McCall1c9c3fd2010-10-15 04:57:14 +0000440 EmitAutoVarDecl(*S.getConditionVariable());
Mike Stump11289f42009-09-09 15:08:12 +0000441
Chris Lattnerb7a9e162008-11-12 07:46:33 +0000442 // If the condition constant folds and can be elided, try to avoid emitting
443 // the condition and the dead arm of the if/else.
Chris Lattner41c6ab52011-02-27 23:02:32 +0000444 bool CondConstant;
445 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) {
Chris Lattneraaaa1992008-11-11 07:24:28 +0000446 // Figure out which block (then or else) is executed.
Chris Lattner41c6ab52011-02-27 23:02:32 +0000447 const Stmt *Executed = S.getThen();
448 const Stmt *Skipped = S.getElse();
449 if (!CondConstant) // Condition false?
Chris Lattneraaaa1992008-11-11 07:24:28 +0000450 std::swap(Executed, Skipped);
Mike Stump11289f42009-09-09 15:08:12 +0000451
Chris Lattneraaaa1992008-11-11 07:24:28 +0000452 // If the skipped block has no labels in it, just emit the executed block.
453 // This avoids emitting dead code and simplifies the CFG substantially.
Chris Lattnerb7a9e162008-11-12 07:46:33 +0000454 if (!ContainsLabel(Skipped)) {
Justin Bogneref512b92014-01-06 22:27:43 +0000455 if (CondConstant)
456 Cnt.beginRegion(Builder);
Douglas Gregor965f4502009-11-24 16:43:22 +0000457 if (Executed) {
John McCallbd309292010-07-06 01:34:17 +0000458 RunCleanupsScope ExecutedScope(*this);
Chris Lattneraaaa1992008-11-11 07:24:28 +0000459 EmitStmt(Executed);
Douglas Gregor965f4502009-11-24 16:43:22 +0000460 }
Chris Lattneraaaa1992008-11-11 07:24:28 +0000461 return;
462 }
463 }
Chris Lattnerb7a9e162008-11-12 07:46:33 +0000464
465 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit
466 // the conditional branch.
Daniel Dunbarf75c8232008-11-13 00:47:57 +0000467 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then");
468 llvm::BasicBlock *ContBlock = createBasicBlock("if.end");
469 llvm::BasicBlock *ElseBlock = ContBlock;
Chris Lattnere47e4402007-06-01 18:02:12 +0000470 if (S.getElse())
Daniel Dunbarf75c8232008-11-13 00:47:57 +0000471 ElseBlock = createBasicBlock("if.else");
Justin Bogneref512b92014-01-06 22:27:43 +0000472
473 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, Cnt.getCount());
Mike Stump11289f42009-09-09 15:08:12 +0000474
Chris Lattnere47e4402007-06-01 18:02:12 +0000475 // Emit the 'then' code.
Justin Bogneref512b92014-01-06 22:27:43 +0000476 EmitBlock(ThenBlock);
477 Cnt.beginRegion(Builder);
Douglas Gregor965f4502009-11-24 16:43:22 +0000478 {
John McCallbd309292010-07-06 01:34:17 +0000479 RunCleanupsScope ThenScope(*this);
Douglas Gregor965f4502009-11-24 16:43:22 +0000480 EmitStmt(S.getThen());
481 }
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000482 EmitBranch(ContBlock);
Mike Stump11289f42009-09-09 15:08:12 +0000483
Chris Lattnere47e4402007-06-01 18:02:12 +0000484 // Emit the 'else' code if present.
485 if (const Stmt *Else = S.getElse()) {
Devang Patel4d761272011-03-30 00:08:31 +0000486 // There is no need to emit line number for unconditional branch.
487 if (getDebugInfo())
488 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
Chris Lattnere47e4402007-06-01 18:02:12 +0000489 EmitBlock(ElseBlock);
Douglas Gregor965f4502009-11-24 16:43:22 +0000490 {
John McCallbd309292010-07-06 01:34:17 +0000491 RunCleanupsScope ElseScope(*this);
Douglas Gregor965f4502009-11-24 16:43:22 +0000492 EmitStmt(Else);
493 }
Devang Patel4d761272011-03-30 00:08:31 +0000494 // There is no need to emit line number for unconditional branch.
495 if (getDebugInfo())
496 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000497 EmitBranch(ContBlock);
Chris Lattnere47e4402007-06-01 18:02:12 +0000498 }
Mike Stump11289f42009-09-09 15:08:12 +0000499
Chris Lattnere47e4402007-06-01 18:02:12 +0000500 // Emit the continuation block for code after the if.
Daniel Dunbardf21c6e2008-11-13 01:54:24 +0000501 EmitBlock(ContBlock, true);
Chris Lattnere47e4402007-06-01 18:02:12 +0000502}
503
Chris Lattner946aa312007-06-05 03:59:43 +0000504void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) {
Justin Bogneref512b92014-01-06 22:27:43 +0000505 RegionCounter Cnt = getPGORegionCounter(&S);
506
John McCallbd309292010-07-06 01:34:17 +0000507 // Emit the header for the loop, which will also become
508 // the continue target.
509 JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond");
John McCallad5d61e2010-07-23 21:56:41 +0000510 EmitBlock(LoopHeader.getBlock());
Mike Stumpdc0d6be2009-02-07 18:08:12 +0000511
John McCallbd309292010-07-06 01:34:17 +0000512 // Create an exit block for when the condition fails, which will
513 // also become the break target.
514 JumpDest LoopExit = getJumpDestInCurrentScope("while.end");
Mike Stumpdc0d6be2009-02-07 18:08:12 +0000515
516 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000517 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
Mike Stump11289f42009-09-09 15:08:12 +0000518
Douglas Gregor680f8612009-11-24 21:15:44 +0000519 // C++ [stmt.while]p2:
520 // When the condition of a while statement is a declaration, the
521 // scope of the variable that is declared extends from its point
522 // of declaration (3.3.2) to the end of the while statement.
523 // [...]
524 // The object created in a condition is destroyed and created
525 // with each iteration of the loop.
John McCallbd309292010-07-06 01:34:17 +0000526 RunCleanupsScope ConditionScope(*this);
Douglas Gregor680f8612009-11-24 21:15:44 +0000527
John McCallbd309292010-07-06 01:34:17 +0000528 if (S.getConditionVariable())
John McCall1c9c3fd2010-10-15 04:57:14 +0000529 EmitAutoVarDecl(*S.getConditionVariable());
Chad Rosierbebf1462012-06-20 17:43:05 +0000530
Mike Stump1f8be1b2009-02-07 17:18:33 +0000531 // Evaluate the conditional in the while header. C99 6.8.5.1: The
532 // evaluation of the controlling expression takes place before each
533 // execution of the loop body.
Chris Lattner8394d792007-06-05 20:53:16 +0000534 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Chad Rosierbebf1462012-06-20 17:43:05 +0000535
Devang Patel152f18f2007-10-09 20:51:27 +0000536 // while(1) is common, avoid extra exit blocks. Be sure
Chris Lattner8394d792007-06-05 20:53:16 +0000537 // to correctly handle break/continue though.
Devang Patel152f18f2007-10-09 20:51:27 +0000538 bool EmitBoolCondBranch = true;
Mike Stump11289f42009-09-09 15:08:12 +0000539 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
Devang Patel152f18f2007-10-09 20:51:27 +0000540 if (C->isOne())
541 EmitBoolCondBranch = false;
Mike Stump11289f42009-09-09 15:08:12 +0000542
Chris Lattner946aa312007-06-05 03:59:43 +0000543 // As long as the condition is true, go to the loop body.
John McCallbd309292010-07-06 01:34:17 +0000544 llvm::BasicBlock *LoopBody = createBasicBlock("while.body");
545 if (EmitBoolCondBranch) {
John McCallad5d61e2010-07-23 21:56:41 +0000546 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
John McCallbd309292010-07-06 01:34:17 +0000547 if (ConditionScope.requiresCleanups())
548 ExitBlock = createBasicBlock("while.exit");
Bob Wilsonbf854f02014-02-17 19:21:09 +0000549 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock,
550 PGO.createLoopWeights(S.getCond(), Cnt));
John McCallbd309292010-07-06 01:34:17 +0000551
John McCallad5d61e2010-07-23 21:56:41 +0000552 if (ExitBlock != LoopExit.getBlock()) {
John McCallbd309292010-07-06 01:34:17 +0000553 EmitBlock(ExitBlock);
554 EmitBranchThroughCleanup(LoopExit);
555 }
556 }
Chad Rosierbebf1462012-06-20 17:43:05 +0000557
John McCallbd309292010-07-06 01:34:17 +0000558 // Emit the loop body. We have to emit this in a cleanup scope
559 // because it might be a singleton DeclStmt.
Douglas Gregor680f8612009-11-24 21:15:44 +0000560 {
John McCallbd309292010-07-06 01:34:17 +0000561 RunCleanupsScope BodyScope(*this);
Douglas Gregor680f8612009-11-24 21:15:44 +0000562 EmitBlock(LoopBody);
Justin Bogneref512b92014-01-06 22:27:43 +0000563 Cnt.beginRegion(Builder);
Douglas Gregor680f8612009-11-24 21:15:44 +0000564 EmitStmt(S.getBody());
565 }
Chris Lattnere73e4322007-07-16 21:28:45 +0000566
Mike Stump11289f42009-09-09 15:08:12 +0000567 BreakContinueStack.pop_back();
568
John McCallbd309292010-07-06 01:34:17 +0000569 // Immediately force cleanup.
570 ConditionScope.ForceCleanup();
Douglas Gregor680f8612009-11-24 21:15:44 +0000571
John McCallbd309292010-07-06 01:34:17 +0000572 // Branch to the loop header again.
John McCallad5d61e2010-07-23 21:56:41 +0000573 EmitBranch(LoopHeader.getBlock());
Mike Stump11289f42009-09-09 15:08:12 +0000574
Chris Lattner946aa312007-06-05 03:59:43 +0000575 // Emit the exit block.
John McCallad5d61e2010-07-23 21:56:41 +0000576 EmitBlock(LoopExit.getBlock(), true);
Douglas Gregor680f8612009-11-24 21:15:44 +0000577
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000578 // The LoopHeader typically is just a branch if we skipped emitting
579 // a branch, try to erase it.
John McCallbd309292010-07-06 01:34:17 +0000580 if (!EmitBoolCondBranch)
John McCallad5d61e2010-07-23 21:56:41 +0000581 SimplifyForwardingBlocks(LoopHeader.getBlock());
Chris Lattner946aa312007-06-05 03:59:43 +0000582}
583
Chris Lattner8394d792007-06-05 20:53:16 +0000584void CodeGenFunction::EmitDoStmt(const DoStmt &S) {
John McCallbd309292010-07-06 01:34:17 +0000585 JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
586 JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
Mike Stump11289f42009-09-09 15:08:12 +0000587
Justin Bogneref512b92014-01-06 22:27:43 +0000588 RegionCounter Cnt = getPGORegionCounter(&S);
589
Chris Lattnere73e4322007-07-16 21:28:45 +0000590 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000591 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
Mike Stump11289f42009-09-09 15:08:12 +0000592
John McCallbd309292010-07-06 01:34:17 +0000593 // Emit the body of the loop.
594 llvm::BasicBlock *LoopBody = createBasicBlock("do.body");
Bob Wilsonbf854f02014-02-17 19:21:09 +0000595 EmitBlockWithFallThrough(LoopBody, Cnt);
John McCallbd309292010-07-06 01:34:17 +0000596 {
597 RunCleanupsScope BodyScope(*this);
598 EmitStmt(S.getBody());
599 }
Mike Stump11289f42009-09-09 15:08:12 +0000600
John McCallad5d61e2010-07-23 21:56:41 +0000601 EmitBlock(LoopCond.getBlock());
Mike Stump11289f42009-09-09 15:08:12 +0000602
Chris Lattner8394d792007-06-05 20:53:16 +0000603 // C99 6.8.5.2: "The evaluation of the controlling expression takes place
604 // after each execution of the loop body."
Mike Stump11289f42009-09-09 15:08:12 +0000605
Chris Lattner8394d792007-06-05 20:53:16 +0000606 // Evaluate the conditional in the while header.
607 // C99 6.8.5p2/p4: The first substatement is executed if the expression
608 // compares unequal to 0. The condition must be a scalar type.
609 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Devang Patelc1380402007-10-09 20:33:39 +0000610
Serge Pavlov09f99242014-01-23 15:05:00 +0000611 BreakContinueStack.pop_back();
612
Devang Patelc1380402007-10-09 20:33:39 +0000613 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure
614 // to correctly handle break/continue though.
615 bool EmitBoolCondBranch = true;
Mike Stump11289f42009-09-09 15:08:12 +0000616 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
Devang Patelc1380402007-10-09 20:33:39 +0000617 if (C->isZero())
618 EmitBoolCondBranch = false;
619
Chris Lattner8394d792007-06-05 20:53:16 +0000620 // As long as the condition is true, iterate the loop.
Justin Bogner2f6b4042014-01-13 21:24:13 +0000621 if (EmitBoolCondBranch)
Justin Bogneref512b92014-01-06 22:27:43 +0000622 Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(),
Bob Wilsonbf854f02014-02-17 19:21:09 +0000623 PGO.createLoopWeights(S.getCond(), Cnt));
Mike Stump11289f42009-09-09 15:08:12 +0000624
Chris Lattner8394d792007-06-05 20:53:16 +0000625 // Emit the exit block.
John McCallad5d61e2010-07-23 21:56:41 +0000626 EmitBlock(LoopExit.getBlock());
Devang Patelc1380402007-10-09 20:33:39 +0000627
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000628 // The DoCond block typically is just a branch if we skipped
629 // emitting a branch, try to erase it.
630 if (!EmitBoolCondBranch)
John McCallad5d61e2010-07-23 21:56:41 +0000631 SimplifyForwardingBlocks(LoopCond.getBlock());
Chris Lattner8394d792007-06-05 20:53:16 +0000632}
633
634void CodeGenFunction::EmitForStmt(const ForStmt &S) {
John McCallbd309292010-07-06 01:34:17 +0000635 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
636
637 RunCleanupsScope ForScope(*this);
Chris Lattnere73e4322007-07-16 21:28:45 +0000638
Devang Patel356e3e02010-08-25 00:28:56 +0000639 CGDebugInfo *DI = getDebugInfo();
Eric Christopher7cdf9482011-10-13 21:45:18 +0000640 if (DI)
641 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
Devang Patel356e3e02010-08-25 00:28:56 +0000642
Chris Lattner8394d792007-06-05 20:53:16 +0000643 // Evaluate the first part before the loop.
644 if (S.getInit())
645 EmitStmt(S.getInit());
646
Bob Wilsonbf854f02014-02-17 19:21:09 +0000647 RegionCounter Cnt = getPGORegionCounter(&S);
648
Chris Lattner8394d792007-06-05 20:53:16 +0000649 // Start the loop with a block that tests the condition.
John McCallbd309292010-07-06 01:34:17 +0000650 // If there's an increment, the continue scope will be overwritten
651 // later.
652 JumpDest Continue = getJumpDestInCurrentScope("for.cond");
John McCallad5d61e2010-07-23 21:56:41 +0000653 llvm::BasicBlock *CondBlock = Continue.getBlock();
Chris Lattner8394d792007-06-05 20:53:16 +0000654 EmitBlock(CondBlock);
655
Serge Pavlov09f99242014-01-23 15:05:00 +0000656 // If the for loop doesn't have an increment we can just use the
657 // condition as the continue block. Otherwise we'll need to create
658 // a block for it (in the current scope, i.e. in the scope of the
659 // condition), and that we will become our continue block.
660 if (S.getInc())
661 Continue = getJumpDestInCurrentScope("for.inc");
662
663 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000664 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
Serge Pavlov09f99242014-01-23 15:05:00 +0000665
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000666 // Create a cleanup scope for the condition variable cleanups.
John McCallbd309292010-07-06 01:34:17 +0000667 RunCleanupsScope ConditionScope(*this);
Chad Rosierbebf1462012-06-20 17:43:05 +0000668
Chris Lattner8394d792007-06-05 20:53:16 +0000669 if (S.getCond()) {
Douglas Gregor7bab5ff2009-11-25 00:27:52 +0000670 // If the for statement has a condition scope, emit the local variable
671 // declaration.
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000672 if (S.getConditionVariable()) {
John McCall1c9c3fd2010-10-15 04:57:14 +0000673 EmitAutoVarDecl(*S.getConditionVariable());
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000674 }
John McCallbd309292010-07-06 01:34:17 +0000675
Justin Bogner085e28e2013-11-04 16:13:18 +0000676 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
John McCallbd309292010-07-06 01:34:17 +0000677 // If there are any cleanups between here and the loop-exit scope,
678 // create a block to stage a loop exit along.
679 if (ForScope.requiresCleanups())
680 ExitBlock = createBasicBlock("for.cond.cleanup");
Chad Rosierbebf1462012-06-20 17:43:05 +0000681
Chris Lattner8394d792007-06-05 20:53:16 +0000682 // As long as the condition is true, iterate the loop.
Daniel Dunbara612e792008-11-13 01:38:36 +0000683 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
Mike Stump11289f42009-09-09 15:08:12 +0000684
Chris Lattnercd439292008-11-12 08:04:58 +0000685 // C99 6.8.5p2/p4: The first substatement is executed if the expression
686 // compares unequal to 0. The condition must be a scalar type.
Justin Bogner7fa2eb92013-11-22 10:20:43 +0000687 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Bob Wilsonbf854f02014-02-17 19:21:09 +0000688 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock,
689 PGO.createLoopWeights(S.getCond(), Cnt));
John McCallbd309292010-07-06 01:34:17 +0000690
John McCallad5d61e2010-07-23 21:56:41 +0000691 if (ExitBlock != LoopExit.getBlock()) {
John McCallbd309292010-07-06 01:34:17 +0000692 EmitBlock(ExitBlock);
693 EmitBranchThroughCleanup(LoopExit);
694 }
Mike Stump11289f42009-09-09 15:08:12 +0000695
696 EmitBlock(ForBody);
Chris Lattner8394d792007-06-05 20:53:16 +0000697 } else {
698 // Treat it as a non-zero constant. Don't even create a new block for the
699 // body, just fall into it.
700 }
Justin Bogneref512b92014-01-06 22:27:43 +0000701 Cnt.beginRegion(Builder);
Chris Lattner8394d792007-06-05 20:53:16 +0000702
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000703 {
704 // Create a separate cleanup scope for the body, in case it is not
705 // a compound statement.
John McCallbd309292010-07-06 01:34:17 +0000706 RunCleanupsScope BodyScope(*this);
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000707 EmitStmt(S.getBody());
708 }
Chris Lattnere73e4322007-07-16 21:28:45 +0000709
Chris Lattner8394d792007-06-05 20:53:16 +0000710 // If there is an increment, emit it next.
Daniel Dunbara2d35702008-09-28 00:19:22 +0000711 if (S.getInc()) {
John McCallad5d61e2010-07-23 21:56:41 +0000712 EmitBlock(Continue.getBlock());
Chris Lattner6278e6a2007-08-11 00:04:45 +0000713 EmitStmt(S.getInc());
Daniel Dunbara2d35702008-09-28 00:19:22 +0000714 }
Mike Stump11289f42009-09-09 15:08:12 +0000715
Douglas Gregor3fe900e2010-05-21 18:36:48 +0000716 BreakContinueStack.pop_back();
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000717
John McCallbd309292010-07-06 01:34:17 +0000718 ConditionScope.ForceCleanup();
719 EmitBranch(CondBlock);
720
721 ForScope.ForceCleanup();
722
Eric Christopher7cdf9482011-10-13 21:45:18 +0000723 if (DI)
724 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
Chris Lattner8394d792007-06-05 20:53:16 +0000725
Chris Lattnere73e4322007-07-16 21:28:45 +0000726 // Emit the fall-through block.
John McCallad5d61e2010-07-23 21:56:41 +0000727 EmitBlock(LoopExit.getBlock(), true);
Chris Lattner8394d792007-06-05 20:53:16 +0000728}
Chris Lattner946aa312007-06-05 03:59:43 +0000729
Richard Smith02e85f32011-04-14 22:09:26 +0000730void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) {
731 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
732
733 RunCleanupsScope ForScope(*this);
734
735 CGDebugInfo *DI = getDebugInfo();
Eric Christopher7cdf9482011-10-13 21:45:18 +0000736 if (DI)
737 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
Richard Smith02e85f32011-04-14 22:09:26 +0000738
739 // Evaluate the first pieces before the loop.
740 EmitStmt(S.getRangeStmt());
741 EmitStmt(S.getBeginEndStmt());
742
Bob Wilsonbf854f02014-02-17 19:21:09 +0000743 RegionCounter Cnt = getPGORegionCounter(&S);
744
Richard Smith02e85f32011-04-14 22:09:26 +0000745 // Start the loop with a block that tests the condition.
746 // If there's an increment, the continue scope will be overwritten
747 // later.
748 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
749 EmitBlock(CondBlock);
750
751 // If there are any cleanups between here and the loop-exit scope,
752 // create a block to stage a loop exit along.
753 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
754 if (ForScope.requiresCleanups())
755 ExitBlock = createBasicBlock("for.cond.cleanup");
Chad Rosierbebf1462012-06-20 17:43:05 +0000756
Richard Smith02e85f32011-04-14 22:09:26 +0000757 // The loop body, consisting of the specified body and the loop variable.
758 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
759
760 // The body is executed if the expression, contextually converted
761 // to bool, is true.
Justin Bogner7fa2eb92013-11-22 10:20:43 +0000762 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Bob Wilsonbf854f02014-02-17 19:21:09 +0000763 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock,
764 PGO.createLoopWeights(S.getCond(), Cnt));
Richard Smith02e85f32011-04-14 22:09:26 +0000765
766 if (ExitBlock != LoopExit.getBlock()) {
767 EmitBlock(ExitBlock);
768 EmitBranchThroughCleanup(LoopExit);
769 }
770
771 EmitBlock(ForBody);
Justin Bogneref512b92014-01-06 22:27:43 +0000772 Cnt.beginRegion(Builder);
Richard Smith02e85f32011-04-14 22:09:26 +0000773
774 // Create a block for the increment. In case of a 'continue', we jump there.
775 JumpDest Continue = getJumpDestInCurrentScope("for.inc");
776
777 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000778 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
Richard Smith02e85f32011-04-14 22:09:26 +0000779
780 {
781 // Create a separate cleanup scope for the loop variable and body.
782 RunCleanupsScope BodyScope(*this);
783 EmitStmt(S.getLoopVarStmt());
784 EmitStmt(S.getBody());
785 }
786
787 // If there is an increment, emit it next.
788 EmitBlock(Continue.getBlock());
789 EmitStmt(S.getInc());
790
791 BreakContinueStack.pop_back();
792
793 EmitBranch(CondBlock);
794
795 ForScope.ForceCleanup();
796
Eric Christopher7cdf9482011-10-13 21:45:18 +0000797 if (DI)
798 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
Richard Smith02e85f32011-04-14 22:09:26 +0000799
800 // Emit the fall-through block.
801 EmitBlock(LoopExit.getBlock(), true);
802}
803
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000804void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) {
805 if (RV.isScalar()) {
806 Builder.CreateStore(RV.getScalarVal(), ReturnValue);
807 } else if (RV.isAggregate()) {
Chad Rosier615ed1a2012-03-29 17:37:10 +0000808 EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000809 } else {
John McCall47fb9502013-03-07 21:37:08 +0000810 EmitStoreOfComplex(RV.getComplexVal(),
811 MakeNaturalAlignAddrLValue(ReturnValue, Ty),
812 /*init*/ true);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000813 }
Anders Carlsson1ac62822009-02-09 20:31:03 +0000814 EmitBranchThroughCleanup(ReturnBlock);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000815}
816
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000817/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand
818/// if the function returns void, or may be missing one if the function returns
819/// non-void. Fun stuff :).
820void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000821 // Emit the result value, even if unused, to evalute the side effects.
822 const Expr *RV = S.getRetValue();
Mike Stump11289f42009-09-09 15:08:12 +0000823
John McCallb0433ee2012-09-25 06:56:03 +0000824 // Treat block literals in a return expression as if they appeared
825 // in their own scope. This permits a small, easily-implemented
826 // exception to our over-conservative rules about not jumping to
827 // statements following block literals with non-trivial cleanups.
828 RunCleanupsScope cleanupScope(*this);
829 if (const ExprWithCleanups *cleanups =
830 dyn_cast_or_null<ExprWithCleanups>(RV)) {
831 enterFullExpression(cleanups);
832 RV = cleanups->getSubExpr();
833 }
834
Daniel Dunbar54bb1932008-09-09 21:00:17 +0000835 // FIXME: Clean this up by using an LValue for ReturnTemp,
836 // EmitStoreThroughLValue, and EmitAnyExpr.
Richard Smith454b4af2014-01-11 01:24:05 +0000837 if (getLangOpts().ElideConstructors &&
838 S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) {
Douglas Gregor290c93e2010-05-15 06:46:45 +0000839 // Apply the named return value optimization for this return statement,
840 // which means doing nothing: the appropriate result has already been
841 // constructed into the NRVO variable.
Chad Rosierbebf1462012-06-20 17:43:05 +0000842
Douglas Gregor9154b5d2010-05-17 15:52:46 +0000843 // If there is an NRVO flag for this variable, set it to 1 into indicate
844 // that the cleanup code should not destroy the variable.
John McCallad7c5c12011-02-08 08:22:06 +0000845 if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()])
846 Builder.CreateStore(Builder.getTrue(), NRVOFlag);
Douglas Gregor290c93e2010-05-15 06:46:45 +0000847 } else if (!ReturnValue) {
Daniel Dunbar54bb1932008-09-09 21:00:17 +0000848 // Make sure not to return anything, but evaluate the expression
849 // for side effects.
850 if (RV)
Eli Friedmanc7460b12008-05-22 01:22:33 +0000851 EmitAnyExpr(RV);
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000852 } else if (RV == 0) {
Daniel Dunbar54bb1932008-09-09 21:00:17 +0000853 // Do nothing (return value is left uninitialized)
Eli Friedmanb909bf42009-05-27 04:56:12 +0000854 } else if (FnRetTy->isReferenceType()) {
855 // If this function returns a reference, take the address of the expression
856 // rather than the value.
Richard Smitha1c9d4d2013-06-12 23:38:09 +0000857 RValue Result = EmitReferenceBindingToExpr(RV);
Douglas Gregor02dde142010-03-24 23:14:04 +0000858 Builder.CreateStore(Result.getScalarVal(), ReturnValue);
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000859 } else {
John McCall47fb9502013-03-07 21:37:08 +0000860 switch (getEvaluationKind(RV->getType())) {
861 case TEK_Scalar:
862 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue);
863 break;
864 case TEK_Complex:
865 EmitComplexExprIntoLValue(RV,
866 MakeNaturalAlignAddrLValue(ReturnValue, RV->getType()),
867 /*isInit*/ true);
868 break;
869 case TEK_Aggregate: {
870 CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType());
871 EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment,
872 Qualifiers(),
873 AggValueSlot::IsDestructed,
874 AggValueSlot::DoesNotNeedGCBarriers,
875 AggValueSlot::IsNotAliased));
876 break;
877 }
878 }
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000879 }
Eli Friedmanc7460b12008-05-22 01:22:33 +0000880
Adrian Prantl8f1fb6f2013-05-07 22:41:09 +0000881 ++NumReturnExprs;
Adrian Prantl3be10542013-05-02 17:30:20 +0000882 if (RV == 0 || RV->isEvaluatable(getContext()))
Adrian Prantl8f1fb6f2013-05-07 22:41:09 +0000883 ++NumSimpleReturnExprs;
Adrian Prantl3be10542013-05-02 17:30:20 +0000884
John McCallb0433ee2012-09-25 06:56:03 +0000885 cleanupScope.ForceCleanup();
Anders Carlsson1ac62822009-02-09 20:31:03 +0000886 EmitBranchThroughCleanup(ReturnBlock);
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000887}
888
Chris Lattner1ad38f82007-06-09 01:20:56 +0000889void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
Devang Patel1b291b22011-06-04 00:38:02 +0000890 // As long as debug info is modeled with instructions, we have to ensure we
891 // have a place to insert here and write the stop point here.
Eric Christopher3910ec92012-04-10 05:04:07 +0000892 if (HaveInsertPoint())
Devang Patel1b291b22011-06-04 00:38:02 +0000893 EmitStopPoint(&S);
894
Ted Kremenek704a2502008-10-06 18:42:27 +0000895 for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end();
896 I != E; ++I)
897 EmitDecl(**I);
Chris Lattnerbd4de5df2007-07-12 15:43:07 +0000898}
Chris Lattnere73e4322007-07-16 21:28:45 +0000899
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000900void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) {
Chris Lattnere73e4322007-07-16 21:28:45 +0000901 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
902
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000903 // If this code is reachable then emit a stop point (if generating
904 // debug info). We have to do this ourselves because we are on the
905 // "simple" statement path.
906 if (HaveInsertPoint())
907 EmitStopPoint(&S);
Mike Stump284d1772009-02-08 09:22:19 +0000908
Bob Wilsonbf854f02014-02-17 19:21:09 +0000909 EmitBranchThroughCleanup(BreakContinueStack.back().BreakBlock);
Chris Lattnere73e4322007-07-16 21:28:45 +0000910}
911
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000912void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) {
Chris Lattnere73e4322007-07-16 21:28:45 +0000913 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
914
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000915 // If this code is reachable then emit a stop point (if generating
916 // debug info). We have to do this ourselves because we are on the
917 // "simple" statement path.
918 if (HaveInsertPoint())
919 EmitStopPoint(&S);
Mike Stump284d1772009-02-08 09:22:19 +0000920
Bob Wilsonbf854f02014-02-17 19:21:09 +0000921 EmitBranchThroughCleanup(BreakContinueStack.back().ContinueBlock);
Chris Lattnere73e4322007-07-16 21:28:45 +0000922}
Devang Patelda5d6bb2007-10-04 23:45:31 +0000923
Devang Patel11663122007-10-08 20:57:48 +0000924/// EmitCaseStmtRange - If case statement range is not too big then
925/// add multiple cases to switch instruction, one for each value within
926/// the range. If range is too big then emit "if" condition check.
927void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
Daniel Dunbar2e0f1cd2008-07-24 01:18:41 +0000928 assert(S.getRHS() && "Expected RHS value in CaseStmt");
Devang Patel11663122007-10-08 20:57:48 +0000929
Richard Smithcaf33902011-10-10 18:28:20 +0000930 llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext());
931 llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext());
Daniel Dunbar2e0f1cd2008-07-24 01:18:41 +0000932
Justin Bogneref512b92014-01-06 22:27:43 +0000933 RegionCounter CaseCnt = getPGORegionCounter(&S);
934
Daniel Dunbar0e5845c2008-07-25 01:11:38 +0000935 // Emit the code for this case. We do this first to make sure it is
936 // properly chained from our predecessor before generating the
937 // switch machinery to enter this block.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000938 llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb");
939 EmitBlockWithFallThrough(CaseDest, CaseCnt);
Daniel Dunbar0e5845c2008-07-25 01:11:38 +0000940 EmitStmt(S.getSubStmt());
941
Daniel Dunbar2e0f1cd2008-07-24 01:18:41 +0000942 // If range is empty, do nothing.
943 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
944 return;
Devang Patel11663122007-10-08 20:57:48 +0000945
946 llvm::APInt Range = RHS - LHS;
Daniel Dunbar0e5845c2008-07-25 01:11:38 +0000947 // FIXME: parameters such as this should not be hardcoded.
Devang Patel11663122007-10-08 20:57:48 +0000948 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
949 // Range is small enough to add multiple switch instruction cases.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000950 uint64_t Total = CaseCnt.getCount();
Justin Bogneref512b92014-01-06 22:27:43 +0000951 unsigned NCases = Range.getZExtValue() + 1;
Justin Bogner3fac6492014-01-13 21:24:25 +0000952 // We only have one region counter for the entire set of cases here, so we
953 // need to divide the weights evenly between the generated cases, ensuring
Bob Wilsona7b16e02014-02-17 19:21:03 +0000954 // that the total weight is preserved. E.g., a weight of 5 over three cases
Justin Bogner3fac6492014-01-13 21:24:25 +0000955 // will be distributed as weights of 2, 2, and 1.
Justin Bogneref512b92014-01-06 22:27:43 +0000956 uint64_t Weight = Total / NCases, Rem = Total % NCases;
957 for (unsigned I = 0; I != NCases; ++I) {
958 if (SwitchWeights)
959 SwitchWeights->push_back(Weight + (Rem ? 1 : 0));
960 if (Rem)
961 Rem--;
Chris Lattner46f16142011-04-19 20:53:45 +0000962 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest);
Devang Patel64a9ca72007-10-05 20:54:07 +0000963 LHS++;
964 }
Devang Patel11663122007-10-08 20:57:48 +0000965 return;
Mike Stump11289f42009-09-09 15:08:12 +0000966 }
967
Daniel Dunbar0e5845c2008-07-25 01:11:38 +0000968 // The range is too big. Emit "if" condition into a new block,
969 // making sure to save and restore the current insertion point.
970 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
Devang Patel64a9ca72007-10-05 20:54:07 +0000971
Daniel Dunbar0e5845c2008-07-25 01:11:38 +0000972 // Push this test onto the chain of range checks (which terminates
973 // in the default basic block). The switch's default will be changed
974 // to the top of this chain after switch emission is complete.
975 llvm::BasicBlock *FalseDest = CaseRangeBlock;
Daniel Dunbar75283ff2008-11-11 02:29:29 +0000976 CaseRangeBlock = createBasicBlock("sw.caserange");
Devang Patel11663122007-10-08 20:57:48 +0000977
Daniel Dunbar0e5845c2008-07-25 01:11:38 +0000978 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
979 Builder.SetInsertPoint(CaseRangeBlock);
Devang Patel11663122007-10-08 20:57:48 +0000980
981 // Emit range check.
Mike Stump11289f42009-09-09 15:08:12 +0000982 llvm::Value *Diff =
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000983 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
Mike Stump11289f42009-09-09 15:08:12 +0000984 llvm::Value *Cond =
Chris Lattner46f16142011-04-19 20:53:45 +0000985 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
Justin Bogneref512b92014-01-06 22:27:43 +0000986
987 llvm::MDNode *Weights = 0;
988 if (SwitchWeights) {
Bob Wilsonbf854f02014-02-17 19:21:09 +0000989 uint64_t ThisCount = CaseCnt.getCount();
Justin Bogneref512b92014-01-06 22:27:43 +0000990 uint64_t DefaultCount = (*SwitchWeights)[0];
991 Weights = PGO.createBranchWeights(ThisCount, DefaultCount);
992
993 // Since we're chaining the switch default through each large case range, we
994 // need to update the weight for the default, ie, the first case, to include
995 // this case.
996 (*SwitchWeights)[0] += ThisCount;
997 }
998 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
Devang Patel11663122007-10-08 20:57:48 +0000999
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001000 // Restore the appropriate insertion point.
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00001001 if (RestoreBB)
1002 Builder.SetInsertPoint(RestoreBB);
1003 else
1004 Builder.ClearInsertionPoint();
Devang Patel11663122007-10-08 20:57:48 +00001005}
1006
1007void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) {
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001008 // If there is no enclosing switch instance that we're aware of, then this
1009 // case statement and its block can be elided. This situation only happens
1010 // when we've constant-folded the switch, are emitting the constant case,
Justin Bogner0f066062013-11-22 10:20:40 +00001011 // and part of the constant case includes another case statement. For
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001012 // instance: switch (4) { case 4: do { case 5: } while (1); }
Fariborz Jahanian07b5f4c2012-01-17 23:55:19 +00001013 if (!SwitchInsn) {
1014 EmitStmt(S.getSubStmt());
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001015 return;
Fariborz Jahanian07b5f4c2012-01-17 23:55:19 +00001016 }
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001017
Chris Lattnerbc204c82011-04-17 00:54:30 +00001018 // Handle case ranges.
Devang Patel11663122007-10-08 20:57:48 +00001019 if (S.getRHS()) {
1020 EmitCaseStmtRange(S);
1021 return;
1022 }
Mike Stump11289f42009-09-09 15:08:12 +00001023
Justin Bogneref512b92014-01-06 22:27:43 +00001024 RegionCounter CaseCnt = getPGORegionCounter(&S);
Chris Lattner46f16142011-04-19 20:53:45 +00001025 llvm::ConstantInt *CaseVal =
Richard Smithcaf33902011-10-10 18:28:20 +00001026 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
Chris Lattner46f16142011-04-19 20:53:45 +00001027
Justin Bognere25ffdf2014-01-21 00:35:11 +00001028 // If the body of the case is just a 'break', try to not emit an empty block.
1029 // If we're profiling or we're not optimizing, leave the block in for better
1030 // debug and coverage analysis.
1031 if (!CGM.getCodeGenOpts().ProfileInstrGenerate &&
1032 CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1033 isa<BreakStmt>(S.getSubStmt())) {
1034 JumpDest Block = BreakContinueStack.back().BreakBlock;
1035
1036 // Only do this optimization if there are no cleanups that need emitting.
1037 if (isObviouslyBranchWithoutCleanups(Block)) {
1038 if (SwitchWeights)
Bob Wilsonbf854f02014-02-17 19:21:09 +00001039 SwitchWeights->push_back(CaseCnt.getCount());
Justin Bognere25ffdf2014-01-21 00:35:11 +00001040 SwitchInsn->addCase(CaseVal, Block.getBlock());
1041
1042 // If there was a fallthrough into this case, make sure to redirect it to
1043 // the end of the switch as well.
1044 if (Builder.GetInsertBlock()) {
1045 Builder.CreateBr(Block.getBlock());
1046 Builder.ClearInsertionPoint();
1047 }
1048 return;
1049 }
1050 }
1051
Bob Wilsonbf854f02014-02-17 19:21:09 +00001052 llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb");
1053 EmitBlockWithFallThrough(CaseDest, CaseCnt);
Justin Bogneref512b92014-01-06 22:27:43 +00001054 if (SwitchWeights)
Bob Wilsonbf854f02014-02-17 19:21:09 +00001055 SwitchWeights->push_back(CaseCnt.getCount());
Chris Lattner46f16142011-04-19 20:53:45 +00001056 SwitchInsn->addCase(CaseVal, CaseDest);
Mike Stump11289f42009-09-09 15:08:12 +00001057
Chris Lattner4192bce2009-03-04 04:46:18 +00001058 // Recursively emitting the statement is acceptable, but is not wonderful for
1059 // code where we have many case statements nested together, i.e.:
1060 // case 1:
1061 // case 2:
1062 // case 3: etc.
1063 // Handling this recursively will create a new block for each case statement
1064 // that falls through to the next case which is IR intensive. It also causes
1065 // deep recursion which can run into stack depth limitations. Handle
1066 // sequential non-range case statements specially.
1067 const CaseStmt *CurCase = &S;
1068 const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt());
1069
Chris Lattner46f16142011-04-19 20:53:45 +00001070 // Otherwise, iteratively add consecutive cases to this switch stmt.
Chris Lattner4192bce2009-03-04 04:46:18 +00001071 while (NextCase && NextCase->getRHS() == 0) {
1072 CurCase = NextCase;
Justin Bogneref512b92014-01-06 22:27:43 +00001073 llvm::ConstantInt *CaseVal =
Richard Smithcaf33902011-10-10 18:28:20 +00001074 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
Justin Bogneref512b92014-01-06 22:27:43 +00001075
1076 CaseCnt = getPGORegionCounter(NextCase);
1077 if (SwitchWeights)
Bob Wilsonbf854f02014-02-17 19:21:09 +00001078 SwitchWeights->push_back(CaseCnt.getCount());
1079 if (CGM.getCodeGenOpts().ProfileInstrGenerate) {
1080 CaseDest = createBasicBlock("sw.bb");
1081 EmitBlockWithFallThrough(CaseDest, CaseCnt);
1082 }
Justin Bogneref512b92014-01-06 22:27:43 +00001083
Chris Lattner46f16142011-04-19 20:53:45 +00001084 SwitchInsn->addCase(CaseVal, CaseDest);
Chris Lattner4192bce2009-03-04 04:46:18 +00001085 NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt());
1086 }
Mike Stump11289f42009-09-09 15:08:12 +00001087
Chris Lattner4192bce2009-03-04 04:46:18 +00001088 // Normal default recursion for non-cases.
1089 EmitStmt(CurCase->getSubStmt());
Devang Patelda5d6bb2007-10-04 23:45:31 +00001090}
1091
1092void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001093 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
Mike Stump11289f42009-09-09 15:08:12 +00001094 assert(DefaultBlock->empty() &&
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001095 "EmitDefaultStmt: Default block already defined?");
Justin Bogneref512b92014-01-06 22:27:43 +00001096
Justin Bogneref512b92014-01-06 22:27:43 +00001097 RegionCounter Cnt = getPGORegionCounter(&S);
Bob Wilsonbf854f02014-02-17 19:21:09 +00001098 EmitBlockWithFallThrough(DefaultBlock, Cnt);
Justin Bogneref512b92014-01-06 22:27:43 +00001099
Devang Patelda5d6bb2007-10-04 23:45:31 +00001100 EmitStmt(S.getSubStmt());
1101}
1102
Chris Lattner0725a8b2011-02-28 00:22:07 +00001103/// CollectStatementsForCase - Given the body of a 'switch' statement and a
1104/// constant value that is being switched on, see if we can dead code eliminate
1105/// the body of the switch to a simple series of statements to emit. Basically,
1106/// on a switch (5) we want to find these statements:
1107/// case 5:
1108/// printf(...); <--
1109/// ++i; <--
1110/// break;
1111///
1112/// and add them to the ResultStmts vector. If it is unsafe to do this
1113/// transformation (for example, one of the elided statements contains a label
1114/// that might be jumped to), return CSFC_Failure. If we handled it and 'S'
1115/// should include statements after it (e.g. the printf() line is a substmt of
1116/// the case) then return CSFC_FallThrough. If we handled it and found a break
1117/// statement, then return CSFC_Success.
1118///
1119/// If Case is non-null, then we are looking for the specified case, checking
1120/// that nothing we jump over contains labels. If Case is null, then we found
1121/// the case and are looking for the break.
1122///
1123/// If the recursive walk actually finds our Case, then we set FoundCase to
1124/// true.
1125///
1126enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success };
1127static CSFC_Result CollectStatementsForCase(const Stmt *S,
1128 const SwitchCase *Case,
1129 bool &FoundCase,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001130 SmallVectorImpl<const Stmt*> &ResultStmts) {
Chris Lattner07095422011-02-28 01:02:29 +00001131 // If this is a null statement, just succeed.
1132 if (S == 0)
1133 return Case ? CSFC_Success : CSFC_FallThrough;
Chad Rosierbebf1462012-06-20 17:43:05 +00001134
Chris Lattner0725a8b2011-02-28 00:22:07 +00001135 // If this is the switchcase (case 4: or default) that we're looking for, then
1136 // we're in business. Just add the substatement.
1137 if (const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1138 if (S == Case) {
1139 FoundCase = true;
1140 return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase,
1141 ResultStmts);
1142 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001143
Chris Lattner0725a8b2011-02-28 00:22:07 +00001144 // Otherwise, this is some other case or default statement, just ignore it.
1145 return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase,
1146 ResultStmts);
1147 }
Chris Lattner07095422011-02-28 01:02:29 +00001148
1149 // If we are in the live part of the code and we found our break statement,
1150 // return a success!
1151 if (Case == 0 && isa<BreakStmt>(S))
1152 return CSFC_Success;
Chad Rosierbebf1462012-06-20 17:43:05 +00001153
Chris Lattner07095422011-02-28 01:02:29 +00001154 // If this is a switch statement, then it might contain the SwitchCase, the
1155 // break, or neither.
1156 if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1157 // Handle this as two cases: we might be looking for the SwitchCase (if so
1158 // the skipped statements must be skippable) or we might already have it.
1159 CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end();
1160 if (Case) {
Chris Lattner35d3ac52011-02-28 07:22:44 +00001161 // Keep track of whether we see a skipped declaration. The code could be
1162 // using the declaration even if it is skipped, so we can't optimize out
1163 // the decl if the kept statements might refer to it.
1164 bool HadSkippedDecl = false;
Chad Rosierbebf1462012-06-20 17:43:05 +00001165
Chris Lattner07095422011-02-28 01:02:29 +00001166 // If we're looking for the case, just see if we can skip each of the
1167 // substatements.
1168 for (; Case && I != E; ++I) {
Eli Friedmane08bca92011-05-21 19:15:39 +00001169 HadSkippedDecl |= isa<DeclStmt>(*I);
Chad Rosierbebf1462012-06-20 17:43:05 +00001170
Chris Lattner07095422011-02-28 01:02:29 +00001171 switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) {
1172 case CSFC_Failure: return CSFC_Failure;
1173 case CSFC_Success:
1174 // A successful result means that either 1) that the statement doesn't
1175 // have the case and is skippable, or 2) does contain the case value
Chris Lattner62208c32011-02-28 07:16:14 +00001176 // and also contains the break to exit the switch. In the later case,
1177 // we just verify the rest of the statements are elidable.
1178 if (FoundCase) {
Chris Lattner35d3ac52011-02-28 07:22:44 +00001179 // If we found the case and skipped declarations, we can't do the
1180 // optimization.
1181 if (HadSkippedDecl)
1182 return CSFC_Failure;
Chad Rosierbebf1462012-06-20 17:43:05 +00001183
Chris Lattner62208c32011-02-28 07:16:14 +00001184 for (++I; I != E; ++I)
1185 if (CodeGenFunction::ContainsLabel(*I, true))
1186 return CSFC_Failure;
1187 return CSFC_Success;
1188 }
Chris Lattner07095422011-02-28 01:02:29 +00001189 break;
1190 case CSFC_FallThrough:
1191 // If we have a fallthrough condition, then we must have found the
1192 // case started to include statements. Consider the rest of the
1193 // statements in the compound statement as candidates for inclusion.
1194 assert(FoundCase && "Didn't find case but returned fallthrough?");
1195 // We recursively found Case, so we're not looking for it anymore.
1196 Case = 0;
Chad Rosierbebf1462012-06-20 17:43:05 +00001197
Chris Lattner35d3ac52011-02-28 07:22:44 +00001198 // If we found the case and skipped declarations, we can't do the
1199 // optimization.
1200 if (HadSkippedDecl)
1201 return CSFC_Failure;
Chris Lattner07095422011-02-28 01:02:29 +00001202 break;
1203 }
1204 }
1205 }
1206
1207 // If we have statements in our range, then we know that the statements are
1208 // live and need to be added to the set of statements we're tracking.
1209 for (; I != E; ++I) {
1210 switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) {
1211 case CSFC_Failure: return CSFC_Failure;
1212 case CSFC_FallThrough:
1213 // A fallthrough result means that the statement was simple and just
1214 // included in ResultStmt, keep adding them afterwards.
1215 break;
1216 case CSFC_Success:
1217 // A successful result means that we found the break statement and
1218 // stopped statement inclusion. We just ensure that any leftover stmts
1219 // are skippable and return success ourselves.
1220 for (++I; I != E; ++I)
1221 if (CodeGenFunction::ContainsLabel(*I, true))
1222 return CSFC_Failure;
1223 return CSFC_Success;
Chad Rosierbebf1462012-06-20 17:43:05 +00001224 }
Chris Lattner07095422011-02-28 01:02:29 +00001225 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001226
Chris Lattner07095422011-02-28 01:02:29 +00001227 return Case ? CSFC_Success : CSFC_FallThrough;
1228 }
1229
Chris Lattner0725a8b2011-02-28 00:22:07 +00001230 // Okay, this is some other statement that we don't handle explicitly, like a
1231 // for statement or increment etc. If we are skipping over this statement,
1232 // just verify it doesn't have labels, which would make it invalid to elide.
1233 if (Case) {
Chris Lattner35d3ac52011-02-28 07:22:44 +00001234 if (CodeGenFunction::ContainsLabel(S, true))
Chris Lattner0725a8b2011-02-28 00:22:07 +00001235 return CSFC_Failure;
1236 return CSFC_Success;
1237 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001238
Chris Lattner0725a8b2011-02-28 00:22:07 +00001239 // Otherwise, we want to include this statement. Everything is cool with that
1240 // so long as it doesn't contain a break out of the switch we're in.
1241 if (CodeGenFunction::containsBreak(S)) return CSFC_Failure;
Chad Rosierbebf1462012-06-20 17:43:05 +00001242
Chris Lattner0725a8b2011-02-28 00:22:07 +00001243 // Otherwise, everything is great. Include the statement and tell the caller
1244 // that we fall through and include the next statement as well.
1245 ResultStmts.push_back(S);
1246 return CSFC_FallThrough;
1247}
1248
1249/// FindCaseStatementsForValue - Find the case statement being jumped to and
1250/// then invoke CollectStatementsForCase to find the list of statements to emit
1251/// for a switch on constant. See the comment above CollectStatementsForCase
1252/// for more details.
1253static bool FindCaseStatementsForValue(const SwitchStmt &S,
Richard Trieuc320c742012-07-23 20:21:35 +00001254 const llvm::APSInt &ConstantCondValue,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001255 SmallVectorImpl<const Stmt*> &ResultStmts,
Justin Bogneref512b92014-01-06 22:27:43 +00001256 ASTContext &C,
1257 const SwitchCase *&ResultCase) {
Chris Lattner0725a8b2011-02-28 00:22:07 +00001258 // First step, find the switch case that is being branched to. We can do this
1259 // efficiently by scanning the SwitchCase list.
1260 const SwitchCase *Case = S.getSwitchCaseList();
1261 const DefaultStmt *DefaultCase = 0;
Chad Rosierbebf1462012-06-20 17:43:05 +00001262
Chris Lattner0725a8b2011-02-28 00:22:07 +00001263 for (; Case; Case = Case->getNextSwitchCase()) {
1264 // It's either a default or case. Just remember the default statement in
1265 // case we're not jumping to any numbered cases.
1266 if (const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1267 DefaultCase = DS;
1268 continue;
1269 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001270
Chris Lattner0725a8b2011-02-28 00:22:07 +00001271 // Check to see if this case is the one we're looking for.
1272 const CaseStmt *CS = cast<CaseStmt>(Case);
1273 // Don't handle case ranges yet.
1274 if (CS->getRHS()) return false;
Chad Rosierbebf1462012-06-20 17:43:05 +00001275
Chris Lattner0725a8b2011-02-28 00:22:07 +00001276 // If we found our case, remember it as 'case'.
Richard Smithcaf33902011-10-10 18:28:20 +00001277 if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue)
Chris Lattner0725a8b2011-02-28 00:22:07 +00001278 break;
1279 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001280
Chris Lattner0725a8b2011-02-28 00:22:07 +00001281 // If we didn't find a matching case, we use a default if it exists, or we
1282 // elide the whole switch body!
1283 if (Case == 0) {
1284 // It is safe to elide the body of the switch if it doesn't contain labels
1285 // etc. If it is safe, return successfully with an empty ResultStmts list.
1286 if (DefaultCase == 0)
1287 return !CodeGenFunction::ContainsLabel(&S);
1288 Case = DefaultCase;
1289 }
1290
1291 // Ok, we know which case is being jumped to, try to collect all the
1292 // statements that follow it. This can fail for a variety of reasons. Also,
1293 // check to see that the recursive walk actually found our case statement.
1294 // Insane cases like this can fail to find it in the recursive walk since we
1295 // don't handle every stmt kind:
1296 // switch (4) {
1297 // while (1) {
1298 // case 4: ...
1299 bool FoundCase = false;
Justin Bogneref512b92014-01-06 22:27:43 +00001300 ResultCase = Case;
Chris Lattner0725a8b2011-02-28 00:22:07 +00001301 return CollectStatementsForCase(S.getBody(), Case, FoundCase,
1302 ResultStmts) != CSFC_Failure &&
1303 FoundCase;
1304}
1305
Devang Patelda5d6bb2007-10-04 23:45:31 +00001306void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) {
John McCallbd309292010-07-06 01:34:17 +00001307 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog");
1308
1309 RunCleanupsScope ConditionScope(*this);
Douglas Gregordcf19622009-11-24 17:07:59 +00001310
1311 if (S.getConditionVariable())
John McCall1c9c3fd2010-10-15 04:57:14 +00001312 EmitAutoVarDecl(*S.getConditionVariable());
Douglas Gregordcf19622009-11-24 17:07:59 +00001313
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001314 // Handle nested switch statements.
1315 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
Justin Bogneref512b92014-01-06 22:27:43 +00001316 SmallVector<uint64_t, 16> *SavedSwitchWeights = SwitchWeights;
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001317 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1318
Chris Lattner0725a8b2011-02-28 00:22:07 +00001319 // See if we can constant fold the condition of the switch and therefore only
1320 // emit the live case statement (if any) of the switch.
Richard Trieuc320c742012-07-23 20:21:35 +00001321 llvm::APSInt ConstantCondValue;
Chris Lattner0725a8b2011-02-28 00:22:07 +00001322 if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001323 SmallVector<const Stmt*, 4> CaseStmts;
Justin Bogneref512b92014-01-06 22:27:43 +00001324 const SwitchCase *Case = 0;
Chris Lattner0725a8b2011-02-28 00:22:07 +00001325 if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts,
Justin Bogneref512b92014-01-06 22:27:43 +00001326 getContext(), Case)) {
Justin Bogneref512b92014-01-06 22:27:43 +00001327 if (Case) {
1328 RegionCounter CaseCnt = getPGORegionCounter(Case);
1329 CaseCnt.beginRegion(Builder);
1330 }
Chris Lattner0725a8b2011-02-28 00:22:07 +00001331 RunCleanupsScope ExecutedScope(*this);
1332
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001333 // At this point, we are no longer "within" a switch instance, so
1334 // we can temporarily enforce this to ensure that any embedded case
1335 // statements are not emitted.
1336 SwitchInsn = 0;
1337
Chris Lattner0725a8b2011-02-28 00:22:07 +00001338 // Okay, we can dead code eliminate everything except this case. Emit the
1339 // specified series of statements and we're good.
1340 for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1341 EmitStmt(CaseStmts[i]);
Justin Bogneref512b92014-01-06 22:27:43 +00001342 RegionCounter ExitCnt = getPGORegionCounter(&S);
1343 ExitCnt.beginRegion(Builder);
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001344
Eric Christophercdbde692012-04-10 05:04:04 +00001345 // Now we want to restore the saved switch instance so that nested
1346 // switches continue to function properly
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001347 SwitchInsn = SavedSwitchInsn;
1348
Chris Lattner0725a8b2011-02-28 00:22:07 +00001349 return;
1350 }
1351 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001352
Devang Patelda5d6bb2007-10-04 23:45:31 +00001353 llvm::Value *CondV = EmitScalarExpr(S.getCond());
1354
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001355 // Create basic block to hold stuff that comes after switch
1356 // statement. We also need to create a default block now so that
1357 // explicit case ranges tests can have a place to jump to on
1358 // failure.
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001359 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default");
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001360 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
Justin Bogneref512b92014-01-06 22:27:43 +00001361 if (PGO.haveRegionCounts()) {
1362 // Walk the SwitchCase list to find how many there are.
1363 uint64_t DefaultCount = 0;
1364 unsigned NumCases = 0;
1365 for (const SwitchCase *Case = S.getSwitchCaseList();
1366 Case;
1367 Case = Case->getNextSwitchCase()) {
1368 if (isa<DefaultStmt>(Case))
1369 DefaultCount = getPGORegionCounter(Case).getCount();
1370 NumCases += 1;
1371 }
1372 SwitchWeights = new SmallVector<uint64_t, 16>();
1373 SwitchWeights->reserve(NumCases);
1374 // The default needs to be first. We store the edge count, so we already
1375 // know the right weight.
1376 SwitchWeights->push_back(DefaultCount);
1377 }
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001378 CaseRangeBlock = DefaultBlock;
Devang Patelda5d6bb2007-10-04 23:45:31 +00001379
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001380 // Clear the insertion point to indicate we are in unreachable code.
1381 Builder.ClearInsertionPoint();
Eli Friedman6a7087e2008-05-12 16:08:04 +00001382
Alp Tokerd4733632013-12-05 04:47:09 +00001383 // All break statements jump to NextBlock. If BreakContinueStack is non-empty
Bob Wilsonbf854f02014-02-17 19:21:09 +00001384 // then reuse last ContinueBlock.
John McCallbd309292010-07-06 01:34:17 +00001385 JumpDest OuterContinue;
Bob Wilsonbf854f02014-02-17 19:21:09 +00001386 if (!BreakContinueStack.empty())
1387 OuterContinue = BreakContinueStack.back().ContinueBlock;
Anders Carlsson33747b62009-02-10 05:52:02 +00001388
Bob Wilsonbf854f02014-02-17 19:21:09 +00001389 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
Devang Patelda5d6bb2007-10-04 23:45:31 +00001390
1391 // Emit switch body.
1392 EmitStmt(S.getBody());
Mike Stump11289f42009-09-09 15:08:12 +00001393
Anders Carlsson33747b62009-02-10 05:52:02 +00001394 BreakContinueStack.pop_back();
Devang Patelda5d6bb2007-10-04 23:45:31 +00001395
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001396 // Update the default block in case explicit case range tests have
1397 // been chained on top.
Stepan Dyatkovskiy5fecf5442012-02-01 07:50:21 +00001398 SwitchInsn->setDefaultDest(CaseRangeBlock);
Mike Stump11289f42009-09-09 15:08:12 +00001399
John McCallbd309292010-07-06 01:34:17 +00001400 // If a default was never emitted:
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001401 if (!DefaultBlock->getParent()) {
John McCallbd309292010-07-06 01:34:17 +00001402 // If we have cleanups, emit the default block so that there's a
1403 // place to jump through the cleanups from.
1404 if (ConditionScope.requiresCleanups()) {
1405 EmitBlock(DefaultBlock);
1406
1407 // Otherwise, just forward the default block to the switch end.
1408 } else {
John McCallad5d61e2010-07-23 21:56:41 +00001409 DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock());
John McCallbd309292010-07-06 01:34:17 +00001410 delete DefaultBlock;
1411 }
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001412 }
Devang Patelda5d6bb2007-10-04 23:45:31 +00001413
John McCallad5d61e2010-07-23 21:56:41 +00001414 ConditionScope.ForceCleanup();
1415
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001416 // Emit continuation.
John McCallad5d61e2010-07-23 21:56:41 +00001417 EmitBlock(SwitchExit.getBlock(), true);
Justin Bogneref512b92014-01-06 22:27:43 +00001418 RegionCounter ExitCnt = getPGORegionCounter(&S);
1419 ExitCnt.beginRegion(Builder);
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001420
Justin Bogneref512b92014-01-06 22:27:43 +00001421 if (SwitchWeights) {
1422 assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&
1423 "switch weights do not match switch cases");
1424 // If there's only one jump destination there's no sense weighting it.
1425 if (SwitchWeights->size() > 1)
1426 SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,
1427 PGO.createBranchWeights(*SwitchWeights));
1428 delete SwitchWeights;
1429 }
Devang Patelda5d6bb2007-10-04 23:45:31 +00001430 SwitchInsn = SavedSwitchInsn;
Justin Bogneref512b92014-01-06 22:27:43 +00001431 SwitchWeights = SavedSwitchWeights;
Devang Patel11663122007-10-08 20:57:48 +00001432 CaseRangeBlock = SavedCRBlock;
Devang Patelda5d6bb2007-10-04 23:45:31 +00001433}
Anders Carlsson952a9952008-02-05 16:35:33 +00001434
Chris Lattnerc16d4762009-04-26 17:57:12 +00001435static std::string
Daniel Dunbar1b444192009-11-13 05:51:54 +00001436SimplifyConstraint(const char *Constraint, const TargetInfo &Target,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001437 SmallVectorImpl<TargetInfo::ConstraintInfo> *OutCons=0) {
Anders Carlsson952a9952008-02-05 16:35:33 +00001438 std::string Result;
Mike Stump11289f42009-09-09 15:08:12 +00001439
Anders Carlsson952a9952008-02-05 16:35:33 +00001440 while (*Constraint) {
1441 switch (*Constraint) {
1442 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001443 Result += Target.convertConstraint(Constraint);
Anders Carlsson952a9952008-02-05 16:35:33 +00001444 break;
1445 // Ignore these
1446 case '*':
1447 case '?':
1448 case '!':
John Thompsona5c7d702010-08-10 19:20:14 +00001449 case '=': // Will see this and the following in mult-alt constraints.
1450 case '+':
1451 break;
Ulrich Weigand7bcc7ec2012-10-29 12:20:54 +00001452 case '#': // Ignore the rest of the constraint alternative.
1453 while (Constraint[1] && Constraint[1] != ',')
Eric Christopher872018b2013-07-10 20:14:36 +00001454 Constraint++;
Ulrich Weigand7bcc7ec2012-10-29 12:20:54 +00001455 break;
John Thompson12240612010-09-18 01:15:13 +00001456 case ',':
1457 Result += "|";
Anders Carlsson952a9952008-02-05 16:35:33 +00001458 break;
1459 case 'g':
1460 Result += "imr";
1461 break;
Anders Carlssona92271d2009-01-18 02:06:20 +00001462 case '[': {
Chris Lattnerc16d4762009-04-26 17:57:12 +00001463 assert(OutCons &&
Anders Carlssona92271d2009-01-18 02:06:20 +00001464 "Must pass output names to constraints with a symbolic name");
1465 unsigned Index;
Mike Stump11289f42009-09-09 15:08:12 +00001466 bool result = Target.resolveSymbolicName(Constraint,
Chris Lattnerc16d4762009-04-26 17:57:12 +00001467 &(*OutCons)[0],
1468 OutCons->size(), Index);
Chris Lattner63c41a22011-01-05 18:41:53 +00001469 assert(result && "Could not resolve symbolic name"); (void)result;
Anders Carlssona92271d2009-01-18 02:06:20 +00001470 Result += llvm::utostr(Index);
1471 break;
1472 }
Anders Carlsson952a9952008-02-05 16:35:33 +00001473 }
Mike Stump11289f42009-09-09 15:08:12 +00001474
Anders Carlsson952a9952008-02-05 16:35:33 +00001475 Constraint++;
1476 }
Mike Stump11289f42009-09-09 15:08:12 +00001477
Anders Carlsson952a9952008-02-05 16:35:33 +00001478 return Result;
1479}
1480
Rafael Espindola5734edc2011-01-01 21:12:33 +00001481/// AddVariableConstraints - Look at AsmExpr and if it is a variable declared
1482/// as using a particular register add that as a constraint that will be used
1483/// in this asm stmt.
Rafael Espindolac56f8472010-12-30 22:59:32 +00001484static std::string
Rafael Espindola5734edc2011-01-01 21:12:33 +00001485AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
1486 const TargetInfo &Target, CodeGenModule &CGM,
Chad Rosier6051bb92012-08-28 18:54:39 +00001487 const AsmStmt &Stmt) {
Rafael Espindolac56f8472010-12-30 22:59:32 +00001488 const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);
1489 if (!AsmDeclRef)
1490 return Constraint;
1491 const ValueDecl &Value = *AsmDeclRef->getDecl();
1492 const VarDecl *Variable = dyn_cast<VarDecl>(&Value);
1493 if (!Variable)
1494 return Constraint;
Eli Friedman6f87b442012-03-15 23:12:51 +00001495 if (Variable->getStorageClass() != SC_Register)
1496 return Constraint;
Rafael Espindolac56f8472010-12-30 22:59:32 +00001497 AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>();
1498 if (!Attr)
1499 return Constraint;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001500 StringRef Register = Attr->getLabel();
Rafael Espindola478abca2011-01-01 21:47:03 +00001501 assert(Target.isValidGCCRegisterName(Register));
Eric Christophere9544252011-06-17 01:53:34 +00001502 // We're using validateOutputConstraint here because we only care if
1503 // this is a register constraint.
1504 TargetInfo::ConstraintInfo Info(Constraint, "");
1505 if (Target.validateOutputConstraint(Info) &&
1506 !Info.allowsRegister()) {
Rafael Espindolac56f8472010-12-30 22:59:32 +00001507 CGM.ErrorUnsupported(&Stmt, "__asm__");
1508 return Constraint;
1509 }
Eric Christopherb4a791f2011-06-21 00:07:10 +00001510 // Canonicalize the register here before returning it.
1511 Register = Target.getNormalizedGCCRegisterName(Register);
Rafael Espindolac56f8472010-12-30 22:59:32 +00001512 return "{" + Register.str() + "}";
1513}
1514
Eli Friedmaneca55af2010-07-16 00:55:21 +00001515llvm::Value*
Chad Rosier59df25b2012-08-23 20:00:18 +00001516CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info,
Eli Friedmaneca55af2010-07-16 00:55:21 +00001517 LValue InputValue, QualType InputType,
Nick Lewycky2d84e842013-10-02 02:29:49 +00001518 std::string &ConstraintStr,
1519 SourceLocation Loc) {
Anders Carlssonda5f5692009-01-11 19:32:54 +00001520 llvm::Value *Arg;
Mike Stump11289f42009-09-09 15:08:12 +00001521 if (Info.allowsRegister() || !Info.allowsMemory()) {
John McCall47fb9502013-03-07 21:37:08 +00001522 if (CodeGenFunction::hasScalarEvaluationKind(InputType)) {
Nick Lewycky2d84e842013-10-02 02:29:49 +00001523 Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal();
Anders Carlssonda5f5692009-01-11 19:32:54 +00001524 } else {
Chris Lattner2192fe52011-07-18 04:24:23 +00001525 llvm::Type *Ty = ConvertType(InputType);
Micah Villmowdd31ca12012-10-08 16:25:52 +00001526 uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty);
Anders Carlsson00057e42009-01-12 02:22:13 +00001527 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
John McCallad7c5c12011-02-08 08:22:06 +00001528 Ty = llvm::IntegerType::get(getLLVMContext(), Size);
Anders Carlsson00057e42009-01-12 02:22:13 +00001529 Ty = llvm::PointerType::getUnqual(Ty);
Mike Stump11289f42009-09-09 15:08:12 +00001530
Eli Friedmaneca55af2010-07-16 00:55:21 +00001531 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1532 Ty));
Anders Carlsson00057e42009-01-12 02:22:13 +00001533 } else {
Eli Friedmaneca55af2010-07-16 00:55:21 +00001534 Arg = InputValue.getAddress();
Anders Carlsson00057e42009-01-12 02:22:13 +00001535 ConstraintStr += '*';
1536 }
Anders Carlssonda5f5692009-01-11 19:32:54 +00001537 }
1538 } else {
Eli Friedmaneca55af2010-07-16 00:55:21 +00001539 Arg = InputValue.getAddress();
Anders Carlssonda5f5692009-01-11 19:32:54 +00001540 ConstraintStr += '*';
1541 }
Mike Stump11289f42009-09-09 15:08:12 +00001542
Anders Carlssonda5f5692009-01-11 19:32:54 +00001543 return Arg;
1544}
1545
Chad Rosier59df25b2012-08-23 20:00:18 +00001546llvm::Value* CodeGenFunction::EmitAsmInput(
Eli Friedmaneca55af2010-07-16 00:55:21 +00001547 const TargetInfo::ConstraintInfo &Info,
1548 const Expr *InputExpr,
1549 std::string &ConstraintStr) {
1550 if (Info.allowsRegister() || !Info.allowsMemory())
John McCall47fb9502013-03-07 21:37:08 +00001551 if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType()))
Eli Friedmaneca55af2010-07-16 00:55:21 +00001552 return EmitScalarExpr(InputExpr);
1553
1554 InputExpr = InputExpr->IgnoreParenNoopCasts(getContext());
1555 LValue Dest = EmitLValue(InputExpr);
Nick Lewycky2d84e842013-10-02 02:29:49 +00001556 return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr,
1557 InputExpr->getExprLoc());
Eli Friedmaneca55af2010-07-16 00:55:21 +00001558}
1559
Chris Lattner776a30d2010-11-17 05:58:54 +00001560/// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline
Chris Lattner11feaf52010-11-17 08:25:26 +00001561/// asm call instruction. The !srcloc MDNode contains a list of constant
1562/// integers which are the source locations of the start of each line in the
1563/// asm.
Chris Lattner776a30d2010-11-17 05:58:54 +00001564static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
1565 CodeGenFunction &CGF) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001566 SmallVector<llvm::Value *, 8> Locs;
Chris Lattner11feaf52010-11-17 08:25:26 +00001567 // Add the location of the first line to the MDNode.
1568 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1569 Str->getLocStart().getRawEncoding()));
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001570 StringRef StrVal = Str->getString();
Chris Lattner11feaf52010-11-17 08:25:26 +00001571 if (!StrVal.empty()) {
1572 const SourceManager &SM = CGF.CGM.getContext().getSourceManager();
David Blaikiebbafb8a2012-03-11 07:00:24 +00001573 const LangOptions &LangOpts = CGF.CGM.getLangOpts();
Chad Rosierbebf1462012-06-20 17:43:05 +00001574
Chris Lattner11feaf52010-11-17 08:25:26 +00001575 // Add the location of the start of each subsequent line of the asm to the
1576 // MDNode.
1577 for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) {
1578 if (StrVal[i] != '\n') continue;
1579 SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts,
John McCallc8e01702013-04-16 22:48:15 +00001580 CGF.getTarget());
Chris Lattner11feaf52010-11-17 08:25:26 +00001581 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1582 LineLoc.getRawEncoding()));
1583 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001584 }
1585
Jay Foadea324f12011-04-21 19:59:12 +00001586 return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
Chris Lattner776a30d2010-11-17 05:58:54 +00001587}
1588
Chad Rosier6051bb92012-08-28 18:54:39 +00001589void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
Chad Rosier14836ba2012-08-24 17:05:45 +00001590 // Assemble the final asm string.
Chad Rosier3b0c2602012-08-27 20:23:31 +00001591 std::string AsmString = S.generateAsmString(getContext());
Mike Stump11289f42009-09-09 15:08:12 +00001592
Chris Lattner17769a32009-05-03 07:05:00 +00001593 // Get all the output and input constraints together.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001594 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1595 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
Chris Lattner17769a32009-05-03 07:05:00 +00001596
Mike Stump11289f42009-09-09 15:08:12 +00001597 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
John McCallf413f5e2013-05-03 00:10:13 +00001598 StringRef Name;
1599 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1600 Name = GAS->getOutputName(i);
1601 TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name);
John McCallc8e01702013-04-16 22:48:15 +00001602 bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid;
Justin Bogner0f066062013-11-22 10:20:40 +00001603 assert(IsValid && "Failed to parse output constraint");
Chris Lattner17769a32009-05-03 07:05:00 +00001604 OutputConstraintInfos.push_back(Info);
Mike Stump11289f42009-09-09 15:08:12 +00001605 }
1606
Chris Lattner17769a32009-05-03 07:05:00 +00001607 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
John McCallf413f5e2013-05-03 00:10:13 +00001608 StringRef Name;
1609 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1610 Name = GAS->getInputName(i);
1611 TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name);
John McCallc8e01702013-04-16 22:48:15 +00001612 bool IsValid =
1613 getTarget().validateInputConstraint(OutputConstraintInfos.data(),
1614 S.getNumOutputs(), Info);
Chris Lattner576def72010-03-03 21:52:23 +00001615 assert(IsValid && "Failed to parse input constraint"); (void)IsValid;
Chris Lattner17769a32009-05-03 07:05:00 +00001616 InputConstraintInfos.push_back(Info);
1617 }
Mike Stump11289f42009-09-09 15:08:12 +00001618
Anders Carlsson952a9952008-02-05 16:35:33 +00001619 std::string Constraints;
Mike Stump11289f42009-09-09 15:08:12 +00001620
Chris Lattner10f221f2009-05-03 07:53:25 +00001621 std::vector<LValue> ResultRegDests;
1622 std::vector<QualType> ResultRegQualTys;
Jay Foad7c57be32011-07-11 09:56:20 +00001623 std::vector<llvm::Type *> ResultRegTypes;
1624 std::vector<llvm::Type *> ResultTruncRegTypes;
Chad Rosier5a032fa2012-05-01 19:53:37 +00001625 std::vector<llvm::Type *> ArgTypes;
Anders Carlsson952a9952008-02-05 16:35:33 +00001626 std::vector<llvm::Value*> Args;
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001627
1628 // Keep track of inout constraints.
1629 std::string InOutConstraints;
1630 std::vector<llvm::Value*> InOutArgs;
Chris Lattnera5f58b02011-07-09 17:41:47 +00001631 std::vector<llvm::Type*> InOutArgTypes;
Anders Carlsson570c3572009-01-27 20:38:24 +00001632
Mike Stump11289f42009-09-09 15:08:12 +00001633 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
Chris Lattner17769a32009-05-03 07:05:00 +00001634 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
Anders Carlsson570c3572009-01-27 20:38:24 +00001635
Anders Carlsson952a9952008-02-05 16:35:33 +00001636 // Simplify the output constraint.
Chris Lattner17769a32009-05-03 07:05:00 +00001637 std::string OutputConstraint(S.getOutputConstraint(i));
John McCallc8e01702013-04-16 22:48:15 +00001638 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1,
1639 getTarget());
Mike Stump11289f42009-09-09 15:08:12 +00001640
Chris Lattnercda4d7e2009-03-13 17:38:01 +00001641 const Expr *OutExpr = S.getOutputExpr(i);
1642 OutExpr = OutExpr->IgnoreParenNoopCasts(getContext());
Mike Stump11289f42009-09-09 15:08:12 +00001643
Eric Christophere97fee62011-06-03 14:52:25 +00001644 OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr,
John McCallc8e01702013-04-16 22:48:15 +00001645 getTarget(), CGM, S);
Rafael Espindolac56f8472010-12-30 22:59:32 +00001646
Chris Lattnercda4d7e2009-03-13 17:38:01 +00001647 LValue Dest = EmitLValue(OutExpr);
Chris Lattner10f221f2009-05-03 07:53:25 +00001648 if (!Constraints.empty())
Anders Carlssonb4e46322009-05-01 00:16:04 +00001649 Constraints += ',';
1650
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001651 // If this is a register output, then make the inline asm return it
1652 // by-value. If this is a memory result, return the value by-reference.
John McCall47fb9502013-03-07 21:37:08 +00001653 if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) {
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001654 Constraints += "=" + OutputConstraint;
Chris Lattner10f221f2009-05-03 07:53:25 +00001655 ResultRegQualTys.push_back(OutExpr->getType());
1656 ResultRegDests.push_back(Dest);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001657 ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType()));
1658 ResultTruncRegTypes.push_back(ResultRegTypes.back());
Mike Stump11289f42009-09-09 15:08:12 +00001659
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001660 // If this output is tied to an input, and if the input is larger, then
1661 // we need to set the actual result type of the inline asm node to be the
1662 // same as the input type.
1663 if (Info.hasMatchingInput()) {
Chris Lattner99837de2009-05-03 08:38:58 +00001664 unsigned InputNo;
1665 for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) {
1666 TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo];
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001667 if (Input.hasTiedOperand() && Input.getTiedOperand() == i)
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001668 break;
Chris Lattner99837de2009-05-03 08:38:58 +00001669 }
1670 assert(InputNo != S.getNumInputs() && "Didn't find matching input!");
Mike Stump11289f42009-09-09 15:08:12 +00001671
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001672 QualType InputTy = S.getInputExpr(InputNo)->getType();
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001673 QualType OutputType = OutExpr->getType();
Mike Stump11289f42009-09-09 15:08:12 +00001674
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001675 uint64_t InputSize = getContext().getTypeSize(InputTy);
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001676 if (getContext().getTypeSize(OutputType) < InputSize) {
1677 // Form the asm to return the value as a larger integer or fp type.
1678 ResultRegTypes.back() = ConvertType(InputTy);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001679 }
1680 }
Tim Northover0ae93912013-06-07 00:04:50 +00001681 if (llvm::Type* AdjTy =
Peter Collingbourne8f5cf742011-02-19 23:03:58 +00001682 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1683 ResultRegTypes.back()))
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001684 ResultRegTypes.back() = AdjTy;
Tim Northover0ae93912013-06-07 00:04:50 +00001685 else {
1686 CGM.getDiags().Report(S.getAsmLoc(),
1687 diag::err_asm_invalid_type_in_input)
1688 << OutExpr->getType() << OutputConstraint;
1689 }
Anders Carlsson952a9952008-02-05 16:35:33 +00001690 } else {
1691 ArgTypes.push_back(Dest.getAddress()->getType());
Anders Carlssond0cd0d82008-02-05 16:57:38 +00001692 Args.push_back(Dest.getAddress());
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001693 Constraints += "=*";
Anders Carlsson952a9952008-02-05 16:35:33 +00001694 Constraints += OutputConstraint;
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001695 }
Mike Stump11289f42009-09-09 15:08:12 +00001696
Chris Lattnerd9725f72009-04-26 07:16:29 +00001697 if (Info.isReadWrite()) {
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001698 InOutConstraints += ',';
Anders Carlssonda5f5692009-01-11 19:32:54 +00001699
Anders Carlsson56388952009-08-04 18:18:36 +00001700 const Expr *InputExpr = S.getOutputExpr(i);
Chad Rosier59df25b2012-08-23 20:00:18 +00001701 llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(),
Nick Lewycky2d84e842013-10-02 02:29:49 +00001702 InOutConstraints,
1703 InputExpr->getExprLoc());
Mike Stump11289f42009-09-09 15:08:12 +00001704
Bill Wendling3b9eaa12012-03-22 23:25:07 +00001705 if (llvm::Type* AdjTy =
Tim Northover0ae93912013-06-07 00:04:50 +00001706 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1707 Arg->getType()))
Bill Wendling3b9eaa12012-03-22 23:25:07 +00001708 Arg = Builder.CreateBitCast(Arg, AdjTy);
1709
Chris Lattnerd9725f72009-04-26 07:16:29 +00001710 if (Info.allowsRegister())
Anders Carlsson431acd12009-01-11 21:23:27 +00001711 InOutConstraints += llvm::utostr(i);
1712 else
1713 InOutConstraints += OutputConstraint;
Anders Carlssona948c342009-01-11 19:46:50 +00001714
Anders Carlsson56388952009-08-04 18:18:36 +00001715 InOutArgTypes.push_back(Arg->getType());
1716 InOutArgs.push_back(Arg);
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001717 }
Anders Carlsson952a9952008-02-05 16:35:33 +00001718 }
Mike Stump11289f42009-09-09 15:08:12 +00001719
Anders Carlsson952a9952008-02-05 16:35:33 +00001720 unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs();
Mike Stump11289f42009-09-09 15:08:12 +00001721
Anders Carlsson952a9952008-02-05 16:35:33 +00001722 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1723 const Expr *InputExpr = S.getInputExpr(i);
1724
Chris Lattner17769a32009-05-03 07:05:00 +00001725 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1726
Chris Lattner10f221f2009-05-03 07:53:25 +00001727 if (!Constraints.empty())
Anders Carlsson952a9952008-02-05 16:35:33 +00001728 Constraints += ',';
Mike Stump11289f42009-09-09 15:08:12 +00001729
Anders Carlsson952a9952008-02-05 16:35:33 +00001730 // Simplify the input constraint.
Chris Lattner17769a32009-05-03 07:05:00 +00001731 std::string InputConstraint(S.getInputConstraint(i));
John McCallc8e01702013-04-16 22:48:15 +00001732 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(),
Chris Lattnerc16d4762009-04-26 17:57:12 +00001733 &OutputConstraintInfos);
Anders Carlsson952a9952008-02-05 16:35:33 +00001734
Rafael Espindolac56f8472010-12-30 22:59:32 +00001735 InputConstraint =
Rafael Espindola5734edc2011-01-01 21:12:33 +00001736 AddVariableConstraints(InputConstraint,
Rafael Espindolac56f8472010-12-30 22:59:32 +00001737 *InputExpr->IgnoreParenNoopCasts(getContext()),
John McCallc8e01702013-04-16 22:48:15 +00001738 getTarget(), CGM, S);
Rafael Espindolac56f8472010-12-30 22:59:32 +00001739
Chad Rosier59df25b2012-08-23 20:00:18 +00001740 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
Mike Stump11289f42009-09-09 15:08:12 +00001741
Chris Lattnerb65933e2009-05-03 07:27:51 +00001742 // If this input argument is tied to a larger output result, extend the
1743 // input to be the same size as the output. The LLVM backend wants to see
1744 // the input and output of a matching constraint be the same size. Note
1745 // that GCC does not define what the top bits are here. We use zext because
1746 // that is usually cheaper, but LLVM IR should really get an anyext someday.
1747 if (Info.hasTiedOperand()) {
1748 unsigned Output = Info.getTiedOperand();
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001749 QualType OutputType = S.getOutputExpr(Output)->getType();
Chris Lattnerb65933e2009-05-03 07:27:51 +00001750 QualType InputTy = InputExpr->getType();
Mike Stump11289f42009-09-09 15:08:12 +00001751
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001752 if (getContext().getTypeSize(OutputType) >
Chris Lattnerb65933e2009-05-03 07:27:51 +00001753 getContext().getTypeSize(InputTy)) {
1754 // Use ptrtoint as appropriate so that we can do our extension.
1755 if (isa<llvm::PointerType>(Arg->getType()))
Chris Lattner5e016ae2010-06-27 07:15:29 +00001756 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy);
Chris Lattner2192fe52011-07-18 04:24:23 +00001757 llvm::Type *OutputTy = ConvertType(OutputType);
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001758 if (isa<llvm::IntegerType>(OutputTy))
1759 Arg = Builder.CreateZExt(Arg, OutputTy);
Peter Collingbourne05500ba2011-07-29 00:24:50 +00001760 else if (isa<llvm::PointerType>(OutputTy))
1761 Arg = Builder.CreateZExt(Arg, IntPtrTy);
1762 else {
1763 assert(OutputTy->isFloatingPointTy() && "Unexpected output type");
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001764 Arg = Builder.CreateFPExt(Arg, OutputTy);
Peter Collingbourne05500ba2011-07-29 00:24:50 +00001765 }
Chris Lattnerb65933e2009-05-03 07:27:51 +00001766 }
1767 }
Bill Wendling3b9eaa12012-03-22 23:25:07 +00001768 if (llvm::Type* AdjTy =
Peter Collingbourne8f5cf742011-02-19 23:03:58 +00001769 getTargetHooks().adjustInlineAsmType(*this, InputConstraint,
1770 Arg->getType()))
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001771 Arg = Builder.CreateBitCast(Arg, AdjTy);
Tim Northover0ae93912013-06-07 00:04:50 +00001772 else
1773 CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input)
1774 << InputExpr->getType() << InputConstraint;
Mike Stump11289f42009-09-09 15:08:12 +00001775
Anders Carlsson952a9952008-02-05 16:35:33 +00001776 ArgTypes.push_back(Arg->getType());
1777 Args.push_back(Arg);
1778 Constraints += InputConstraint;
1779 }
Mike Stump11289f42009-09-09 15:08:12 +00001780
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001781 // Append the "input" part of inout constraints last.
1782 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
1783 ArgTypes.push_back(InOutArgTypes[i]);
1784 Args.push_back(InOutArgs[i]);
1785 }
1786 Constraints += InOutConstraints;
Mike Stump11289f42009-09-09 15:08:12 +00001787
Anders Carlsson952a9952008-02-05 16:35:33 +00001788 // Clobbers
1789 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
Chad Rosier6100ae12012-08-27 23:47:56 +00001790 StringRef Clobber = S.getClobber(i);
Anders Carlsson952a9952008-02-05 16:35:33 +00001791
Eric Christopherfd9a5f42011-06-28 18:20:53 +00001792 if (Clobber != "memory" && Clobber != "cc")
John McCallc8e01702013-04-16 22:48:15 +00001793 Clobber = getTarget().getNormalizedGCCRegisterName(Clobber);
Mike Stump11289f42009-09-09 15:08:12 +00001794
Anders Carlsson3ed4aea2008-02-06 00:11:32 +00001795 if (i != 0 || NumConstraints != 0)
Anders Carlsson952a9952008-02-05 16:35:33 +00001796 Constraints += ',';
Mike Stump11289f42009-09-09 15:08:12 +00001797
Anders Carlsson3ed4aea2008-02-06 00:11:32 +00001798 Constraints += "~{";
Anders Carlsson952a9952008-02-05 16:35:33 +00001799 Constraints += Clobber;
Anders Carlsson3ed4aea2008-02-06 00:11:32 +00001800 Constraints += '}';
Anders Carlsson952a9952008-02-05 16:35:33 +00001801 }
Mike Stump11289f42009-09-09 15:08:12 +00001802
Anders Carlsson952a9952008-02-05 16:35:33 +00001803 // Add machine specific clobbers
John McCallc8e01702013-04-16 22:48:15 +00001804 std::string MachineClobbers = getTarget().getClobbers();
Eli Friedmandea41932008-12-21 01:15:32 +00001805 if (!MachineClobbers.empty()) {
Anders Carlsson952a9952008-02-05 16:35:33 +00001806 if (!Constraints.empty())
1807 Constraints += ',';
Eli Friedmandea41932008-12-21 01:15:32 +00001808 Constraints += MachineClobbers;
Anders Carlsson952a9952008-02-05 16:35:33 +00001809 }
Anders Carlssonb4e46322009-05-01 00:16:04 +00001810
Chris Lattner2192fe52011-07-18 04:24:23 +00001811 llvm::Type *ResultType;
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001812 if (ResultRegTypes.empty())
Chris Lattnerece04092012-02-07 00:39:47 +00001813 ResultType = VoidTy;
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001814 else if (ResultRegTypes.size() == 1)
1815 ResultType = ResultRegTypes[0];
Anders Carlssonb4e46322009-05-01 00:16:04 +00001816 else
John McCallad7c5c12011-02-08 08:22:06 +00001817 ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes);
Mike Stump11289f42009-09-09 15:08:12 +00001818
Chris Lattner2192fe52011-07-18 04:24:23 +00001819 llvm::FunctionType *FTy =
Anders Carlsson952a9952008-02-05 16:35:33 +00001820 llvm::FunctionType::get(ResultType, ArgTypes, false);
Mike Stump11289f42009-09-09 15:08:12 +00001821
Chad Rosier7ea9ce72012-09-04 19:50:17 +00001822 bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0;
Chad Rosier7cf5a442012-09-05 19:01:07 +00001823 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?
1824 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
Mike Stump11289f42009-09-09 15:08:12 +00001825 llvm::InlineAsm *IA =
Chad Rosiereb31ef02012-09-04 23:08:24 +00001826 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
Chad Rosier7cf5a442012-09-05 19:01:07 +00001827 /* IsAlignStack */ false, AsmDialect);
Jay Foad5bd375a2011-07-15 08:37:34 +00001828 llvm::CallInst *Result = Builder.CreateCall(IA, Args);
Bill Wendling3087d022012-12-07 23:17:26 +00001829 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
Peter Collingbourne2ee0b632013-03-02 01:20:22 +00001830 llvm::Attribute::NoUnwind);
Mike Stump11289f42009-09-09 15:08:12 +00001831
Chris Lattnerfdb76cc2010-04-07 05:46:54 +00001832 // Slap the source location of the inline asm into a !srcloc metadata on the
Chad Rosier6051bb92012-08-28 18:54:39 +00001833 // call. FIXME: Handle metadata for MS-style inline asms.
1834 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S))
1835 Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(),
1836 *this));
Mike Stump11289f42009-09-09 15:08:12 +00001837
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001838 // Extract all of the register value results from the asm.
1839 std::vector<llvm::Value*> RegResults;
1840 if (ResultRegTypes.size() == 1) {
1841 RegResults.push_back(Result);
Anders Carlssonb4e46322009-05-01 00:16:04 +00001842 } else {
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001843 for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
Anders Carlssonb4e46322009-05-01 00:16:04 +00001844 llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult");
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001845 RegResults.push_back(Tmp);
Anders Carlssonb4e46322009-05-01 00:16:04 +00001846 }
1847 }
Mike Stump11289f42009-09-09 15:08:12 +00001848
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001849 for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {
1850 llvm::Value *Tmp = RegResults[i];
Mike Stump11289f42009-09-09 15:08:12 +00001851
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001852 // If the result type of the LLVM IR asm doesn't match the result type of
1853 // the expression, do the conversion.
1854 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
Chris Lattner2192fe52011-07-18 04:24:23 +00001855 llvm::Type *TruncTy = ResultTruncRegTypes[i];
Chad Rosierbebf1462012-06-20 17:43:05 +00001856
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001857 // Truncate the integer result to the right size, note that TruncTy can be
1858 // a pointer.
1859 if (TruncTy->isFloatingPointTy())
1860 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy);
Dan Gohman7905d182010-04-24 04:55:02 +00001861 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
Micah Villmowdd31ca12012-10-08 16:25:52 +00001862 uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy);
John McCallad7c5c12011-02-08 08:22:06 +00001863 Tmp = Builder.CreateTrunc(Tmp,
1864 llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize));
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001865 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy);
Dan Gohman7905d182010-04-24 04:55:02 +00001866 } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
Micah Villmowdd31ca12012-10-08 16:25:52 +00001867 uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType());
John McCallad7c5c12011-02-08 08:22:06 +00001868 Tmp = Builder.CreatePtrToInt(Tmp,
1869 llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize));
Dan Gohman7905d182010-04-24 04:55:02 +00001870 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
1871 } else if (TruncTy->isIntegerTy()) {
1872 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001873 } else if (TruncTy->isVectorTy()) {
1874 Tmp = Builder.CreateBitCast(Tmp, TruncTy);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001875 }
1876 }
Mike Stump11289f42009-09-09 15:08:12 +00001877
John McCall55e1fbc2011-06-25 02:11:03 +00001878 EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001879 }
Anders Carlsson952a9952008-02-05 16:35:33 +00001880}
Tareq A. Siraj24110cc2013-04-16 18:53:08 +00001881
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00001882static LValue InitCapturedStruct(CodeGenFunction &CGF, const CapturedStmt &S) {
1883 const RecordDecl *RD = S.getCapturedRecordDecl();
1884 QualType RecordTy = CGF.getContext().getRecordType(RD);
1885
1886 // Initialize the captured struct.
1887 LValue SlotLV = CGF.MakeNaturalAlignAddrLValue(
1888 CGF.CreateMemTemp(RecordTy, "agg.captured"), RecordTy);
1889
1890 RecordDecl::field_iterator CurField = RD->field_begin();
1891 for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(),
1892 E = S.capture_init_end();
1893 I != E; ++I, ++CurField) {
1894 LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField);
1895 CGF.EmitInitializerForField(*CurField, LV, *I, ArrayRef<VarDecl *>());
1896 }
1897
1898 return SlotLV;
1899}
1900
1901/// Generate an outlined function for the body of a CapturedStmt, store any
1902/// captured variables into the captured struct, and call the outlined function.
1903llvm::Function *
1904CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) {
1905 const CapturedDecl *CD = S.getCapturedDecl();
1906 const RecordDecl *RD = S.getCapturedRecordDecl();
1907 assert(CD->hasBody() && "missing CapturedDecl body");
1908
1909 LValue CapStruct = InitCapturedStruct(*this, S);
1910
1911 // Emit the CapturedDecl
1912 CodeGenFunction CGF(CGM, true);
1913 CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K);
Nick Lewycky2d84e842013-10-02 02:29:49 +00001914 llvm::Function *F = CGF.GenerateCapturedStmtFunction(CD, RD, S.getLocStart());
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00001915 delete CGF.CapturedStmtInfo;
1916
1917 // Emit call to the helper function.
1918 EmitCallOrInvoke(F, CapStruct.getAddress());
1919
1920 return F;
1921}
1922
1923/// Creates the outlined function for a CapturedStmt.
1924llvm::Function *
1925CodeGenFunction::GenerateCapturedStmtFunction(const CapturedDecl *CD,
Nick Lewycky2d84e842013-10-02 02:29:49 +00001926 const RecordDecl *RD,
1927 SourceLocation Loc) {
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00001928 assert(CapturedStmtInfo &&
1929 "CapturedStmtInfo should be set when generating the captured function");
1930
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00001931 // Build the argument list.
1932 ASTContext &Ctx = CGM.getContext();
1933 FunctionArgList Args;
1934 Args.append(CD->param_begin(), CD->param_end());
1935
1936 // Create the function declaration.
1937 FunctionType::ExtInfo ExtInfo;
1938 const CGFunctionInfo &FuncInfo =
Reid Kleckner4982b822014-01-31 22:54:50 +00001939 CGM.getTypes().arrangeFreeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo,
1940 /*IsVariadic=*/false);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00001941 llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo);
1942
1943 llvm::Function *F =
1944 llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,
1945 CapturedStmtInfo->getHelperName(), &CGM.getModule());
1946 CGM.SetInternalFunctionAttributes(CD, F, FuncInfo);
1947
1948 // Generate the function.
1949 StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getBody()->getLocStart());
1950
1951 // Set the context parameter in CapturedStmtInfo.
1952 llvm::Value *DeclPtr = LocalDeclMap[CD->getContextParam()];
1953 assert(DeclPtr && "missing context parameter for CapturedStmt");
1954 CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr));
1955
1956 // If 'this' is captured, load it into CXXThisValue.
1957 if (CapturedStmtInfo->isCXXThisExprCaptured()) {
1958 FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl();
1959 LValue LV = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(),
1960 Ctx.getTagDeclType(RD));
1961 LValue ThisLValue = EmitLValueForField(LV, FD);
Nick Lewycky2d84e842013-10-02 02:29:49 +00001962 CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal();
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00001963 }
1964
1965 CapturedStmtInfo->EmitBody(*this, CD->getBody());
1966 FinishFunction(CD->getBodyRBrace());
1967
1968 return F;
Tareq A. Siraj24110cc2013-04-16 18:53:08 +00001969}