blob: 97755e3906d8dd2f2edc095832544d323cca311c [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Stmt nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000014#include "CGDebugInfo.h"
15#include "CodeGenModule.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000016#include "CodeGenFunction.h"
Peter Collingbourne4b93d662011-02-19 23:03:58 +000017#include "TargetInfo.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000018#include "clang/AST/StmtVisitor.h"
Chris Lattner7d22bf02009-03-05 08:04:57 +000019#include "clang/Basic/PrettyStackTrace.h"
Anders Carlssonfb1aeb82008-02-05 16:35:33 +000020#include "clang/Basic/TargetInfo.h"
Anders Carlssonfb1aeb82008-02-05 16:35:33 +000021#include "llvm/ADT/StringExtras.h"
Anders Carlsson17d28a32008-12-12 05:52:00 +000022#include "llvm/InlineAsm.h"
23#include "llvm/Intrinsics.h"
Anders Carlssonebaae2a2009-01-12 02:22:13 +000024#include "llvm/Target/TargetData.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000025using namespace clang;
26using namespace CodeGen;
27
28//===----------------------------------------------------------------------===//
29// Statement Emission
30//===----------------------------------------------------------------------===//
31
Daniel Dunbar09124252008-11-12 08:21:33 +000032void CodeGenFunction::EmitStopPoint(const Stmt *S) {
Anders Carlssone896d982009-02-13 08:11:52 +000033 if (CGDebugInfo *DI = getDebugInfo()) {
Eric Christopher73fb3502011-10-13 21:45:18 +000034 SourceLocation Loc;
Devang Patel60e4fd92010-05-12 00:39:34 +000035 if (isa<DeclStmt>(S))
Eric Christopher73fb3502011-10-13 21:45:18 +000036 Loc = S->getLocEnd();
Devang Patel60e4fd92010-05-12 00:39:34 +000037 else
Eric Christopher73fb3502011-10-13 21:45:18 +000038 Loc = S->getLocStart();
39 DI->EmitLocation(Builder, Loc);
Daniel Dunbar09124252008-11-12 08:21:33 +000040 }
41}
42
Reid Spencer5f016e22007-07-11 17:01:13 +000043void CodeGenFunction::EmitStmt(const Stmt *S) {
44 assert(S && "Null statement?");
Daniel Dunbara448fb22008-11-11 23:11:34 +000045
Eric Christopherf9aac382011-09-26 15:03:19 +000046 // These statements have their own debug info handling.
Daniel Dunbar09124252008-11-12 08:21:33 +000047 if (EmitSimpleStmt(S))
48 return;
49
Daniel Dunbard286f052009-07-19 06:58:07 +000050 // Check if we are generating unreachable code.
51 if (!HaveInsertPoint()) {
52 // If so, and the statement doesn't contain a label, then we do not need to
53 // generate actual code. This is safe because (1) the current point is
54 // unreachable, so we don't need to execute the code, and (2) we've already
55 // handled the statements which update internal data structures (like the
56 // local variable map) which could be used by subsequent statements.
57 if (!ContainsLabel(S)) {
58 // Verify that any decl statements were handled as simple, they may be in
59 // scope of subsequent reachable statements.
60 assert(!isa<DeclStmt>(*S) && "Unexpected DeclStmt!");
61 return;
62 }
63
64 // Otherwise, make a new block to hold the code.
65 EnsureInsertPoint();
66 }
67
Daniel Dunbar09124252008-11-12 08:21:33 +000068 // Generate a stoppoint if we are emitting debug info.
69 EmitStopPoint(S);
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000070
Reid Spencer5f016e22007-07-11 17:01:13 +000071 switch (S->getStmtClass()) {
John McCall2a416372010-12-05 02:00:02 +000072 case Stmt::NoStmtClass:
73 case Stmt::CXXCatchStmtClass:
John Wiegley28bbe4b2011-04-28 01:08:34 +000074 case Stmt::SEHExceptStmtClass:
75 case Stmt::SEHFinallyStmtClass:
Douglas Gregorba0513d2011-10-25 01:33:02 +000076 case Stmt::MSDependentExistsStmtClass:
John McCall2a416372010-12-05 02:00:02 +000077 llvm_unreachable("invalid statement class to emit generically");
78 case Stmt::NullStmtClass:
79 case Stmt::CompoundStmtClass:
80 case Stmt::DeclStmtClass:
81 case Stmt::LabelStmtClass:
82 case Stmt::GotoStmtClass:
83 case Stmt::BreakStmtClass:
84 case Stmt::ContinueStmtClass:
85 case Stmt::DefaultStmtClass:
86 case Stmt::CaseStmtClass:
87 llvm_unreachable("should have emitted these statements as simple");
Daniel Dunbarcd5e60e2009-07-19 08:23:12 +000088
John McCall2a416372010-12-05 02:00:02 +000089#define STMT(Type, Base)
90#define ABSTRACT_STMT(Op)
91#define EXPR(Type, Base) \
92 case Stmt::Type##Class:
93#include "clang/AST/StmtNodes.inc"
John McCallcd5b22e2011-01-12 03:41:02 +000094 {
95 // Remember the block we came in on.
96 llvm::BasicBlock *incoming = Builder.GetInsertBlock();
97 assert(incoming && "expression emission must have an insertion point");
98
John McCall2a416372010-12-05 02:00:02 +000099 EmitIgnoredExpr(cast<Expr>(S));
Mike Stump1eb44332009-09-09 15:08:12 +0000100
John McCallcd5b22e2011-01-12 03:41:02 +0000101 llvm::BasicBlock *outgoing = Builder.GetInsertBlock();
102 assert(outgoing && "expression emission cleared block!");
103
104 // The expression emitters assume (reasonably!) that the insertion
105 // point is always set. To maintain that, the call-emission code
106 // for noreturn functions has to enter a new block with no
107 // predecessors. We want to kill that block and mark the current
108 // insertion point unreachable in the common case of a call like
109 // "exit();". Since expression emission doesn't otherwise create
110 // blocks with no predecessors, we can just test for that.
111 // However, we must be careful not to do this to our incoming
112 // block, because *statement* emission does sometimes create
113 // reachable blocks which will have no predecessors until later in
114 // the function. This occurs with, e.g., labels that are not
115 // reachable by fallthrough.
116 if (incoming != outgoing && outgoing->use_empty()) {
117 outgoing->eraseFromParent();
118 Builder.ClearInsertionPoint();
Reid Spencer5f016e22007-07-11 17:01:13 +0000119 }
120 break;
John McCallcd5b22e2011-01-12 03:41:02 +0000121 }
John McCall2a416372010-12-05 02:00:02 +0000122
Mike Stump1eb44332009-09-09 15:08:12 +0000123 case Stmt::IndirectGotoStmtClass:
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000124 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000125
126 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break;
127 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break;
128 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break;
129 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break;
Mike Stump1eb44332009-09-09 15:08:12 +0000130
Reid Spencer5f016e22007-07-11 17:01:13 +0000131 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break;
Daniel Dunbara4275d12008-10-02 18:02:06 +0000132
Devang Patel51b09f22007-10-04 23:45:31 +0000133 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break;
Anders Carlssonfb1aeb82008-02-05 16:35:33 +0000134 case Stmt::AsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break;
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000135
136 case Stmt::ObjCAtTryStmtClass:
Anders Carlsson64d5d6c2008-09-09 10:04:29 +0000137 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
Mike Stump1eb44332009-09-09 15:08:12 +0000138 break;
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000139 case Stmt::ObjCAtCatchStmtClass:
David Blaikieb219cfc2011-09-23 05:06:16 +0000140 llvm_unreachable(
141 "@catch statements should be handled by EmitObjCAtTryStmt");
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000142 case Stmt::ObjCAtFinallyStmtClass:
David Blaikieb219cfc2011-09-23 05:06:16 +0000143 llvm_unreachable(
144 "@finally statements should be handled by EmitObjCAtTryStmt");
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000145 case Stmt::ObjCAtThrowStmtClass:
Anders Carlsson64d5d6c2008-09-09 10:04:29 +0000146 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000147 break;
148 case Stmt::ObjCAtSynchronizedStmtClass:
Chris Lattner10cac6f2008-11-15 21:26:17 +0000149 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S));
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000150 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000151 case Stmt::ObjCForCollectionStmtClass:
Anders Carlsson3d8400d2008-08-30 19:51:14 +0000152 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000153 break;
John McCallf85e1932011-06-15 23:02:42 +0000154 case Stmt::ObjCAutoreleasePoolStmtClass:
155 EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S));
156 break;
Anders Carlsson6815e942009-09-27 18:58:34 +0000157
158 case Stmt::CXXTryStmtClass:
159 EmitCXXTryStmt(cast<CXXTryStmt>(*S));
160 break;
Richard Smithad762fc2011-04-14 22:09:26 +0000161 case Stmt::CXXForRangeStmtClass:
162 EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S));
John Wiegley28bbe4b2011-04-28 01:08:34 +0000163 case Stmt::SEHTryStmtClass:
164 // FIXME Not yet implemented
Richard Smithad762fc2011-04-14 22:09:26 +0000165 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000166 }
167}
168
Daniel Dunbar09124252008-11-12 08:21:33 +0000169bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
170 switch (S->getStmtClass()) {
171 default: return false;
172 case Stmt::NullStmtClass: break;
173 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
Daniel Dunbard286f052009-07-19 06:58:07 +0000174 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break;
Daniel Dunbar09124252008-11-12 08:21:33 +0000175 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break;
176 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break;
177 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break;
178 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break;
179 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break;
180 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break;
181 }
182
183 return true;
184}
185
Chris Lattner33793202007-08-31 22:09:40 +0000186/// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true,
187/// this captures the expression result of the last sub-statement and returns it
188/// (for use by the statement expression extension).
Chris Lattner9b655512007-08-31 22:49:20 +0000189RValue CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
John McCall558d2ab2010-09-15 10:14:12 +0000190 AggValueSlot AggSlot) {
Chris Lattner7d22bf02009-03-05 08:04:57 +0000191 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(),
192 "LLVM IR generation of compound statement ('{}')");
Mike Stump1eb44332009-09-09 15:08:12 +0000193
Anders Carlssone896d982009-02-13 08:11:52 +0000194 CGDebugInfo *DI = getDebugInfo();
Eric Christopher73fb3502011-10-13 21:45:18 +0000195 if (DI)
196 DI->EmitLexicalBlockStart(Builder, S.getLBracLoc());
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000197
Anders Carlssonc71c8452009-02-07 23:50:39 +0000198 // Keep track of the current cleanup stack depth.
John McCallf1549f62010-07-06 01:34:17 +0000199 RunCleanupsScope Scope(*this);
Mike Stump1eb44332009-09-09 15:08:12 +0000200
Chris Lattner33793202007-08-31 22:09:40 +0000201 for (CompoundStmt::const_body_iterator I = S.body_begin(),
202 E = S.body_end()-GetLast; I != E; ++I)
Reid Spencer5f016e22007-07-11 17:01:13 +0000203 EmitStmt(*I);
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000204
Eric Christopher73fb3502011-10-13 21:45:18 +0000205 if (DI)
206 DI->EmitLexicalBlockEnd(Builder, S.getRBracLoc());
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000207
Anders Carlsson17d28a32008-12-12 05:52:00 +0000208 RValue RV;
Mike Stump1eb44332009-09-09 15:08:12 +0000209 if (!GetLast)
Anders Carlsson17d28a32008-12-12 05:52:00 +0000210 RV = RValue::get(0);
211 else {
Mike Stump1eb44332009-09-09 15:08:12 +0000212 // We have to special case labels here. They are statements, but when put
Anders Carlsson17d28a32008-12-12 05:52:00 +0000213 // at the end of a statement expression, they yield the value of their
214 // subexpression. Handle this by walking through all labels we encounter,
215 // emitting them before we evaluate the subexpr.
216 const Stmt *LastStmt = S.body_back();
217 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000218 EmitLabel(LS->getDecl());
Anders Carlsson17d28a32008-12-12 05:52:00 +0000219 LastStmt = LS->getSubStmt();
220 }
Mike Stump1eb44332009-09-09 15:08:12 +0000221
Anders Carlsson17d28a32008-12-12 05:52:00 +0000222 EnsureInsertPoint();
Mike Stump1eb44332009-09-09 15:08:12 +0000223
John McCall558d2ab2010-09-15 10:14:12 +0000224 RV = EmitAnyExpr(cast<Expr>(LastStmt), AggSlot);
Anders Carlsson17d28a32008-12-12 05:52:00 +0000225 }
226
Anders Carlsson17d28a32008-12-12 05:52:00 +0000227 return RV;
Reid Spencer5f016e22007-07-11 17:01:13 +0000228}
229
Daniel Dunbaraa5bd872009-04-01 04:37:47 +0000230void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) {
231 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
Mike Stump1eb44332009-09-09 15:08:12 +0000232
Daniel Dunbaraa5bd872009-04-01 04:37:47 +0000233 // If there is a cleanup stack, then we it isn't worth trying to
234 // simplify this block (we would need to remove it from the scope map
235 // and cleanup entry).
John McCallf1549f62010-07-06 01:34:17 +0000236 if (!EHStack.empty())
Daniel Dunbaraa5bd872009-04-01 04:37:47 +0000237 return;
238
239 // Can only simplify direct branches.
240 if (!BI || !BI->isUnconditional())
241 return;
242
243 BB->replaceAllUsesWith(BI->getSuccessor(0));
244 BI->eraseFromParent();
245 BB->eraseFromParent();
246}
247
Daniel Dunbara0c21a82008-11-13 01:24:05 +0000248void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) {
John McCall548ce5e2010-04-21 11:18:06 +0000249 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
250
Daniel Dunbard57a8712008-11-11 09:41:28 +0000251 // Fall out of the current block (if necessary).
252 EmitBranch(BB);
Daniel Dunbara0c21a82008-11-13 01:24:05 +0000253
254 if (IsFinished && BB->use_empty()) {
255 delete BB;
256 return;
257 }
258
John McCall839cbaa2010-04-21 10:29:06 +0000259 // Place the block after the current block, if possible, or else at
260 // the end of the function.
John McCall548ce5e2010-04-21 11:18:06 +0000261 if (CurBB && CurBB->getParent())
262 CurFn->getBasicBlockList().insertAfter(CurBB, BB);
John McCall839cbaa2010-04-21 10:29:06 +0000263 else
264 CurFn->getBasicBlockList().push_back(BB);
Reid Spencer5f016e22007-07-11 17:01:13 +0000265 Builder.SetInsertPoint(BB);
266}
267
Daniel Dunbard57a8712008-11-11 09:41:28 +0000268void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) {
269 // Emit a branch from the current block to the target one if this
270 // was a real block. If this was just a fall-through block after a
271 // terminator, don't emit it.
272 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
273
274 if (!CurBB || CurBB->getTerminator()) {
275 // If there is no insert point or the previous block is already
276 // terminated, don't touch it.
Daniel Dunbard57a8712008-11-11 09:41:28 +0000277 } else {
278 // Otherwise, create a fall-through branch.
279 Builder.CreateBr(Target);
280 }
Daniel Dunbar5e08ad32008-11-11 22:06:59 +0000281
282 Builder.ClearInsertionPoint();
Daniel Dunbard57a8712008-11-11 09:41:28 +0000283}
284
John McCall777d6e52011-08-11 02:22:43 +0000285void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) {
286 bool inserted = false;
287 for (llvm::BasicBlock::use_iterator
288 i = block->use_begin(), e = block->use_end(); i != e; ++i) {
289 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(*i)) {
290 CurFn->getBasicBlockList().insertAfter(insn->getParent(), block);
291 inserted = true;
292 break;
293 }
294 }
295
296 if (!inserted)
297 CurFn->getBasicBlockList().push_back(block);
298
299 Builder.SetInsertPoint(block);
300}
301
John McCallf1549f62010-07-06 01:34:17 +0000302CodeGenFunction::JumpDest
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000303CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) {
304 JumpDest &Dest = LabelMap[D];
John McCallff8e1152010-07-23 21:56:41 +0000305 if (Dest.isValid()) return Dest;
John McCallf1549f62010-07-06 01:34:17 +0000306
307 // Create, but don't insert, the new block.
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000308 Dest = JumpDest(createBasicBlock(D->getName()),
John McCallff8e1152010-07-23 21:56:41 +0000309 EHScopeStack::stable_iterator::invalid(),
310 NextCleanupDestIndex++);
John McCallf1549f62010-07-06 01:34:17 +0000311 return Dest;
312}
313
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000314void CodeGenFunction::EmitLabel(const LabelDecl *D) {
315 JumpDest &Dest = LabelMap[D];
John McCallf1549f62010-07-06 01:34:17 +0000316
John McCallff8e1152010-07-23 21:56:41 +0000317 // If we didn't need a forward reference to this label, just go
John McCallf1549f62010-07-06 01:34:17 +0000318 // ahead and create a destination at the current scope.
John McCallff8e1152010-07-23 21:56:41 +0000319 if (!Dest.isValid()) {
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000320 Dest = getJumpDestInCurrentScope(D->getName());
John McCallf1549f62010-07-06 01:34:17 +0000321
322 // Otherwise, we need to give this label a target depth and remove
323 // it from the branch-fixups list.
324 } else {
John McCallff8e1152010-07-23 21:56:41 +0000325 assert(!Dest.getScopeDepth().isValid() && "already emitted label!");
326 Dest = JumpDest(Dest.getBlock(),
327 EHStack.stable_begin(),
328 Dest.getDestIndex());
John McCallf1549f62010-07-06 01:34:17 +0000329
John McCallff8e1152010-07-23 21:56:41 +0000330 ResolveBranchFixups(Dest.getBlock());
John McCallf1549f62010-07-06 01:34:17 +0000331 }
332
John McCallff8e1152010-07-23 21:56:41 +0000333 EmitBlock(Dest.getBlock());
Chris Lattner91d723d2008-07-26 20:23:23 +0000334}
335
336
337void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000338 EmitLabel(S.getDecl());
Reid Spencer5f016e22007-07-11 17:01:13 +0000339 EmitStmt(S.getSubStmt());
340}
341
342void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
Daniel Dunbar09124252008-11-12 08:21:33 +0000343 // If this code is reachable then emit a stop point (if generating
344 // debug info). We have to do this ourselves because we are on the
345 // "simple" statement path.
346 if (HaveInsertPoint())
347 EmitStopPoint(&S);
Mike Stump36a2ada2009-02-07 12:52:26 +0000348
John McCallf1549f62010-07-06 01:34:17 +0000349 EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel()));
Reid Spencer5f016e22007-07-11 17:01:13 +0000350}
351
Chris Lattner3d00fdc2009-10-13 06:55:33 +0000352
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000353void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000354 if (const LabelDecl *Target = S.getConstantTarget()) {
John McCall95c225d2010-10-28 08:53:48 +0000355 EmitBranchThroughCleanup(getJumpDestForLabel(Target));
356 return;
357 }
358
Chris Lattner49c952f2009-11-06 18:10:47 +0000359 // Ensure that we have an i8* for our PHI node.
Chris Lattnerd9becd12009-10-28 23:59:40 +0000360 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
John McCalld16c2cf2011-02-08 08:22:06 +0000361 Int8PtrTy, "addr");
Chris Lattner3d00fdc2009-10-13 06:55:33 +0000362 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
363
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000364
Chris Lattner3d00fdc2009-10-13 06:55:33 +0000365 // Get the basic block for the indirect goto.
366 llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock();
367
368 // The first instruction in the block has to be the PHI for the switch dest,
369 // add an entry for this branch.
370 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
371
372 EmitBranch(IndGotoBB);
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000373}
374
Chris Lattner62b72f62008-11-11 07:24:28 +0000375void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000376 // C99 6.8.4.1: The first substatement is executed if the expression compares
377 // unequal to 0. The condition must be a scalar type.
John McCallf1549f62010-07-06 01:34:17 +0000378 RunCleanupsScope ConditionScope(*this);
Douglas Gregor01234bb2009-11-24 16:43:22 +0000379
Douglas Gregor8cfe5a72009-11-23 23:44:04 +0000380 if (S.getConditionVariable())
John McCallb6bbcc92010-10-15 04:57:14 +0000381 EmitAutoVarDecl(*S.getConditionVariable());
Mike Stump1eb44332009-09-09 15:08:12 +0000382
Chris Lattner9bc47e22008-11-12 07:46:33 +0000383 // If the condition constant folds and can be elided, try to avoid emitting
384 // the condition and the dead arm of the if/else.
Chris Lattnerc2c90012011-02-27 23:02:32 +0000385 bool CondConstant;
386 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) {
Chris Lattner62b72f62008-11-11 07:24:28 +0000387 // Figure out which block (then or else) is executed.
Chris Lattnerc2c90012011-02-27 23:02:32 +0000388 const Stmt *Executed = S.getThen();
389 const Stmt *Skipped = S.getElse();
390 if (!CondConstant) // Condition false?
Chris Lattner62b72f62008-11-11 07:24:28 +0000391 std::swap(Executed, Skipped);
Mike Stump1eb44332009-09-09 15:08:12 +0000392
Chris Lattner62b72f62008-11-11 07:24:28 +0000393 // If the skipped block has no labels in it, just emit the executed block.
394 // This avoids emitting dead code and simplifies the CFG substantially.
Chris Lattner9bc47e22008-11-12 07:46:33 +0000395 if (!ContainsLabel(Skipped)) {
Douglas Gregor01234bb2009-11-24 16:43:22 +0000396 if (Executed) {
John McCallf1549f62010-07-06 01:34:17 +0000397 RunCleanupsScope ExecutedScope(*this);
Chris Lattner62b72f62008-11-11 07:24:28 +0000398 EmitStmt(Executed);
Douglas Gregor01234bb2009-11-24 16:43:22 +0000399 }
Chris Lattner62b72f62008-11-11 07:24:28 +0000400 return;
401 }
402 }
Chris Lattner9bc47e22008-11-12 07:46:33 +0000403
404 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit
405 // the conditional branch.
Daniel Dunbar781d7ca2008-11-13 00:47:57 +0000406 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then");
407 llvm::BasicBlock *ContBlock = createBasicBlock("if.end");
408 llvm::BasicBlock *ElseBlock = ContBlock;
Reid Spencer5f016e22007-07-11 17:01:13 +0000409 if (S.getElse())
Daniel Dunbar781d7ca2008-11-13 00:47:57 +0000410 ElseBlock = createBasicBlock("if.else");
411 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000412
Reid Spencer5f016e22007-07-11 17:01:13 +0000413 // Emit the 'then' code.
Douglas Gregor01234bb2009-11-24 16:43:22 +0000414 EmitBlock(ThenBlock);
415 {
John McCallf1549f62010-07-06 01:34:17 +0000416 RunCleanupsScope ThenScope(*this);
Douglas Gregor01234bb2009-11-24 16:43:22 +0000417 EmitStmt(S.getThen());
418 }
Daniel Dunbard57a8712008-11-11 09:41:28 +0000419 EmitBranch(ContBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000420
Reid Spencer5f016e22007-07-11 17:01:13 +0000421 // Emit the 'else' code if present.
422 if (const Stmt *Else = S.getElse()) {
Devang Patelacd72362011-03-30 00:08:31 +0000423 // There is no need to emit line number for unconditional branch.
424 if (getDebugInfo())
425 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
Reid Spencer5f016e22007-07-11 17:01:13 +0000426 EmitBlock(ElseBlock);
Douglas Gregor01234bb2009-11-24 16:43:22 +0000427 {
John McCallf1549f62010-07-06 01:34:17 +0000428 RunCleanupsScope ElseScope(*this);
Douglas Gregor01234bb2009-11-24 16:43:22 +0000429 EmitStmt(Else);
430 }
Devang Patelacd72362011-03-30 00:08:31 +0000431 // There is no need to emit line number for unconditional branch.
432 if (getDebugInfo())
433 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
Daniel Dunbard57a8712008-11-11 09:41:28 +0000434 EmitBranch(ContBlock);
Reid Spencer5f016e22007-07-11 17:01:13 +0000435 }
Mike Stump1eb44332009-09-09 15:08:12 +0000436
Reid Spencer5f016e22007-07-11 17:01:13 +0000437 // Emit the continuation block for code after the if.
Daniel Dunbarc22d6652008-11-13 01:54:24 +0000438 EmitBlock(ContBlock, true);
Reid Spencer5f016e22007-07-11 17:01:13 +0000439}
440
441void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) {
John McCallf1549f62010-07-06 01:34:17 +0000442 // Emit the header for the loop, which will also become
443 // the continue target.
444 JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond");
John McCallff8e1152010-07-23 21:56:41 +0000445 EmitBlock(LoopHeader.getBlock());
Mike Stump72cac2c2009-02-07 18:08:12 +0000446
John McCallf1549f62010-07-06 01:34:17 +0000447 // Create an exit block for when the condition fails, which will
448 // also become the break target.
449 JumpDest LoopExit = getJumpDestInCurrentScope("while.end");
Mike Stump72cac2c2009-02-07 18:08:12 +0000450
451 // Store the blocks to use for break and continue.
John McCallf1549f62010-07-06 01:34:17 +0000452 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
Mike Stump1eb44332009-09-09 15:08:12 +0000453
Douglas Gregor5656e142009-11-24 21:15:44 +0000454 // C++ [stmt.while]p2:
455 // When the condition of a while statement is a declaration, the
456 // scope of the variable that is declared extends from its point
457 // of declaration (3.3.2) to the end of the while statement.
458 // [...]
459 // The object created in a condition is destroyed and created
460 // with each iteration of the loop.
John McCallf1549f62010-07-06 01:34:17 +0000461 RunCleanupsScope ConditionScope(*this);
Douglas Gregor5656e142009-11-24 21:15:44 +0000462
John McCallf1549f62010-07-06 01:34:17 +0000463 if (S.getConditionVariable())
John McCallb6bbcc92010-10-15 04:57:14 +0000464 EmitAutoVarDecl(*S.getConditionVariable());
Douglas Gregor5656e142009-11-24 21:15:44 +0000465
Mike Stump16b16202009-02-07 17:18:33 +0000466 // Evaluate the conditional in the while header. C99 6.8.5.1: The
467 // evaluation of the controlling expression takes place before each
468 // execution of the loop body.
Reid Spencer5f016e22007-07-11 17:01:13 +0000469 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Douglas Gregor5656e142009-11-24 21:15:44 +0000470
Devang Patel2c30d8f2007-10-09 20:51:27 +0000471 // while(1) is common, avoid extra exit blocks. Be sure
Reid Spencer5f016e22007-07-11 17:01:13 +0000472 // to correctly handle break/continue though.
Devang Patel2c30d8f2007-10-09 20:51:27 +0000473 bool EmitBoolCondBranch = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000474 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
Devang Patel2c30d8f2007-10-09 20:51:27 +0000475 if (C->isOne())
476 EmitBoolCondBranch = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000477
Reid Spencer5f016e22007-07-11 17:01:13 +0000478 // As long as the condition is true, go to the loop body.
John McCallf1549f62010-07-06 01:34:17 +0000479 llvm::BasicBlock *LoopBody = createBasicBlock("while.body");
480 if (EmitBoolCondBranch) {
John McCallff8e1152010-07-23 21:56:41 +0000481 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
John McCallf1549f62010-07-06 01:34:17 +0000482 if (ConditionScope.requiresCleanups())
483 ExitBlock = createBasicBlock("while.exit");
484
485 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock);
486
John McCallff8e1152010-07-23 21:56:41 +0000487 if (ExitBlock != LoopExit.getBlock()) {
John McCallf1549f62010-07-06 01:34:17 +0000488 EmitBlock(ExitBlock);
489 EmitBranchThroughCleanup(LoopExit);
490 }
491 }
Douglas Gregor5656e142009-11-24 21:15:44 +0000492
John McCallf1549f62010-07-06 01:34:17 +0000493 // Emit the loop body. We have to emit this in a cleanup scope
494 // because it might be a singleton DeclStmt.
Douglas Gregor5656e142009-11-24 21:15:44 +0000495 {
John McCallf1549f62010-07-06 01:34:17 +0000496 RunCleanupsScope BodyScope(*this);
Douglas Gregor5656e142009-11-24 21:15:44 +0000497 EmitBlock(LoopBody);
498 EmitStmt(S.getBody());
499 }
Chris Lattnerda138702007-07-16 21:28:45 +0000500
Mike Stump1eb44332009-09-09 15:08:12 +0000501 BreakContinueStack.pop_back();
502
John McCallf1549f62010-07-06 01:34:17 +0000503 // Immediately force cleanup.
504 ConditionScope.ForceCleanup();
Douglas Gregor5656e142009-11-24 21:15:44 +0000505
John McCallf1549f62010-07-06 01:34:17 +0000506 // Branch to the loop header again.
John McCallff8e1152010-07-23 21:56:41 +0000507 EmitBranch(LoopHeader.getBlock());
Mike Stump1eb44332009-09-09 15:08:12 +0000508
Reid Spencer5f016e22007-07-11 17:01:13 +0000509 // Emit the exit block.
John McCallff8e1152010-07-23 21:56:41 +0000510 EmitBlock(LoopExit.getBlock(), true);
Douglas Gregor5656e142009-11-24 21:15:44 +0000511
Daniel Dunbaraa5bd872009-04-01 04:37:47 +0000512 // The LoopHeader typically is just a branch if we skipped emitting
513 // a branch, try to erase it.
John McCallf1549f62010-07-06 01:34:17 +0000514 if (!EmitBoolCondBranch)
John McCallff8e1152010-07-23 21:56:41 +0000515 SimplifyForwardingBlocks(LoopHeader.getBlock());
Reid Spencer5f016e22007-07-11 17:01:13 +0000516}
517
518void CodeGenFunction::EmitDoStmt(const DoStmt &S) {
John McCallf1549f62010-07-06 01:34:17 +0000519 JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
520 JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
Mike Stump1eb44332009-09-09 15:08:12 +0000521
Chris Lattnerda138702007-07-16 21:28:45 +0000522 // Store the blocks to use for break and continue.
John McCallf1549f62010-07-06 01:34:17 +0000523 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
Mike Stump1eb44332009-09-09 15:08:12 +0000524
John McCallf1549f62010-07-06 01:34:17 +0000525 // Emit the body of the loop.
526 llvm::BasicBlock *LoopBody = createBasicBlock("do.body");
527 EmitBlock(LoopBody);
528 {
529 RunCleanupsScope BodyScope(*this);
530 EmitStmt(S.getBody());
531 }
Mike Stump1eb44332009-09-09 15:08:12 +0000532
Anders Carlssone4b6d342009-02-10 05:52:02 +0000533 BreakContinueStack.pop_back();
Mike Stump1eb44332009-09-09 15:08:12 +0000534
John McCallff8e1152010-07-23 21:56:41 +0000535 EmitBlock(LoopCond.getBlock());
Mike Stump1eb44332009-09-09 15:08:12 +0000536
Reid Spencer5f016e22007-07-11 17:01:13 +0000537 // C99 6.8.5.2: "The evaluation of the controlling expression takes place
538 // after each execution of the loop body."
Mike Stump1eb44332009-09-09 15:08:12 +0000539
Reid Spencer5f016e22007-07-11 17:01:13 +0000540 // Evaluate the conditional in the while header.
541 // C99 6.8.5p2/p4: The first substatement is executed if the expression
542 // compares unequal to 0. The condition must be a scalar type.
543 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Devang Patel05f6e6b2007-10-09 20:33:39 +0000544
545 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure
546 // to correctly handle break/continue though.
547 bool EmitBoolCondBranch = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000548 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
Devang Patel05f6e6b2007-10-09 20:33:39 +0000549 if (C->isZero())
550 EmitBoolCondBranch = false;
551
Reid Spencer5f016e22007-07-11 17:01:13 +0000552 // As long as the condition is true, iterate the loop.
Devang Patel05f6e6b2007-10-09 20:33:39 +0000553 if (EmitBoolCondBranch)
John McCallff8e1152010-07-23 21:56:41 +0000554 Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock());
Mike Stump1eb44332009-09-09 15:08:12 +0000555
Reid Spencer5f016e22007-07-11 17:01:13 +0000556 // Emit the exit block.
John McCallff8e1152010-07-23 21:56:41 +0000557 EmitBlock(LoopExit.getBlock());
Devang Patel05f6e6b2007-10-09 20:33:39 +0000558
Daniel Dunbaraa5bd872009-04-01 04:37:47 +0000559 // The DoCond block typically is just a branch if we skipped
560 // emitting a branch, try to erase it.
561 if (!EmitBoolCondBranch)
John McCallff8e1152010-07-23 21:56:41 +0000562 SimplifyForwardingBlocks(LoopCond.getBlock());
Reid Spencer5f016e22007-07-11 17:01:13 +0000563}
564
565void CodeGenFunction::EmitForStmt(const ForStmt &S) {
John McCallf1549f62010-07-06 01:34:17 +0000566 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
567
568 RunCleanupsScope ForScope(*this);
Chris Lattnerda138702007-07-16 21:28:45 +0000569
Devang Patel0554e0e2010-08-25 00:28:56 +0000570 CGDebugInfo *DI = getDebugInfo();
Eric Christopher73fb3502011-10-13 21:45:18 +0000571 if (DI)
572 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
Devang Patel0554e0e2010-08-25 00:28:56 +0000573
Reid Spencer5f016e22007-07-11 17:01:13 +0000574 // Evaluate the first part before the loop.
575 if (S.getInit())
576 EmitStmt(S.getInit());
577
578 // Start the loop with a block that tests the condition.
John McCallf1549f62010-07-06 01:34:17 +0000579 // If there's an increment, the continue scope will be overwritten
580 // later.
581 JumpDest Continue = getJumpDestInCurrentScope("for.cond");
John McCallff8e1152010-07-23 21:56:41 +0000582 llvm::BasicBlock *CondBlock = Continue.getBlock();
Reid Spencer5f016e22007-07-11 17:01:13 +0000583 EmitBlock(CondBlock);
584
Douglas Gregord9752062009-11-25 01:51:31 +0000585 // Create a cleanup scope for the condition variable cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000586 RunCleanupsScope ConditionScope(*this);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +0000587
Douglas Gregord9752062009-11-25 01:51:31 +0000588 llvm::Value *BoolCondVal = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +0000589 if (S.getCond()) {
Douglas Gregor99e9b4d2009-11-25 00:27:52 +0000590 // If the for statement has a condition scope, emit the local variable
591 // declaration.
John McCallff8e1152010-07-23 21:56:41 +0000592 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
Douglas Gregord9752062009-11-25 01:51:31 +0000593 if (S.getConditionVariable()) {
John McCallb6bbcc92010-10-15 04:57:14 +0000594 EmitAutoVarDecl(*S.getConditionVariable());
Douglas Gregord9752062009-11-25 01:51:31 +0000595 }
John McCallf1549f62010-07-06 01:34:17 +0000596
597 // If there are any cleanups between here and the loop-exit scope,
598 // create a block to stage a loop exit along.
599 if (ForScope.requiresCleanups())
600 ExitBlock = createBasicBlock("for.cond.cleanup");
Douglas Gregor99e9b4d2009-11-25 00:27:52 +0000601
Reid Spencer5f016e22007-07-11 17:01:13 +0000602 // As long as the condition is true, iterate the loop.
Daniel Dunbar9615ecb2008-11-13 01:38:36 +0000603 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
Mike Stump1eb44332009-09-09 15:08:12 +0000604
Chris Lattner31a09842008-11-12 08:04:58 +0000605 // C99 6.8.5p2/p4: The first substatement is executed if the expression
606 // compares unequal to 0. The condition must be a scalar type.
Douglas Gregord9752062009-11-25 01:51:31 +0000607 BoolCondVal = EvaluateExprAsBool(S.getCond());
John McCallf1549f62010-07-06 01:34:17 +0000608 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock);
609
John McCallff8e1152010-07-23 21:56:41 +0000610 if (ExitBlock != LoopExit.getBlock()) {
John McCallf1549f62010-07-06 01:34:17 +0000611 EmitBlock(ExitBlock);
612 EmitBranchThroughCleanup(LoopExit);
613 }
Mike Stump1eb44332009-09-09 15:08:12 +0000614
615 EmitBlock(ForBody);
Reid Spencer5f016e22007-07-11 17:01:13 +0000616 } else {
617 // Treat it as a non-zero constant. Don't even create a new block for the
618 // body, just fall into it.
619 }
620
Mike Stump1eb44332009-09-09 15:08:12 +0000621 // If the for loop doesn't have an increment we can just use the
John McCallf1549f62010-07-06 01:34:17 +0000622 // condition as the continue block. Otherwise we'll need to create
623 // a block for it (in the current scope, i.e. in the scope of the
624 // condition), and that we will become our continue block.
Chris Lattnerda138702007-07-16 21:28:45 +0000625 if (S.getInc())
John McCallf1549f62010-07-06 01:34:17 +0000626 Continue = getJumpDestInCurrentScope("for.inc");
Mike Stump1eb44332009-09-09 15:08:12 +0000627
Chris Lattnerda138702007-07-16 21:28:45 +0000628 // Store the blocks to use for break and continue.
John McCallf1549f62010-07-06 01:34:17 +0000629 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
Mike Stump3e9da662009-02-07 23:02:10 +0000630
Douglas Gregord9752062009-11-25 01:51:31 +0000631 {
632 // Create a separate cleanup scope for the body, in case it is not
633 // a compound statement.
John McCallf1549f62010-07-06 01:34:17 +0000634 RunCleanupsScope BodyScope(*this);
Douglas Gregord9752062009-11-25 01:51:31 +0000635 EmitStmt(S.getBody());
636 }
Chris Lattnerda138702007-07-16 21:28:45 +0000637
Reid Spencer5f016e22007-07-11 17:01:13 +0000638 // If there is an increment, emit it next.
Daniel Dunbarad12b6d2008-09-28 00:19:22 +0000639 if (S.getInc()) {
John McCallff8e1152010-07-23 21:56:41 +0000640 EmitBlock(Continue.getBlock());
Chris Lattner883f6a72007-08-11 00:04:45 +0000641 EmitStmt(S.getInc());
Daniel Dunbarad12b6d2008-09-28 00:19:22 +0000642 }
Mike Stump1eb44332009-09-09 15:08:12 +0000643
Douglas Gregor45d3fe12010-05-21 18:36:48 +0000644 BreakContinueStack.pop_back();
Douglas Gregord9752062009-11-25 01:51:31 +0000645
John McCallf1549f62010-07-06 01:34:17 +0000646 ConditionScope.ForceCleanup();
647 EmitBranch(CondBlock);
648
649 ForScope.ForceCleanup();
650
Eric Christopher73fb3502011-10-13 21:45:18 +0000651 if (DI)
652 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
Reid Spencer5f016e22007-07-11 17:01:13 +0000653
Chris Lattnerda138702007-07-16 21:28:45 +0000654 // Emit the fall-through block.
John McCallff8e1152010-07-23 21:56:41 +0000655 EmitBlock(LoopExit.getBlock(), true);
Reid Spencer5f016e22007-07-11 17:01:13 +0000656}
657
Richard Smithad762fc2011-04-14 22:09:26 +0000658void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) {
659 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
660
661 RunCleanupsScope ForScope(*this);
662
663 CGDebugInfo *DI = getDebugInfo();
Eric Christopher73fb3502011-10-13 21:45:18 +0000664 if (DI)
665 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
Richard Smithad762fc2011-04-14 22:09:26 +0000666
667 // Evaluate the first pieces before the loop.
668 EmitStmt(S.getRangeStmt());
669 EmitStmt(S.getBeginEndStmt());
670
671 // Start the loop with a block that tests the condition.
672 // If there's an increment, the continue scope will be overwritten
673 // later.
674 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
675 EmitBlock(CondBlock);
676
677 // If there are any cleanups between here and the loop-exit scope,
678 // create a block to stage a loop exit along.
679 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
680 if (ForScope.requiresCleanups())
681 ExitBlock = createBasicBlock("for.cond.cleanup");
682
683 // The loop body, consisting of the specified body and the loop variable.
684 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
685
686 // The body is executed if the expression, contextually converted
687 // to bool, is true.
688 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
689 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock);
690
691 if (ExitBlock != LoopExit.getBlock()) {
692 EmitBlock(ExitBlock);
693 EmitBranchThroughCleanup(LoopExit);
694 }
695
696 EmitBlock(ForBody);
697
698 // Create a block for the increment. In case of a 'continue', we jump there.
699 JumpDest Continue = getJumpDestInCurrentScope("for.inc");
700
701 // Store the blocks to use for break and continue.
702 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
703
704 {
705 // Create a separate cleanup scope for the loop variable and body.
706 RunCleanupsScope BodyScope(*this);
707 EmitStmt(S.getLoopVarStmt());
708 EmitStmt(S.getBody());
709 }
710
711 // If there is an increment, emit it next.
712 EmitBlock(Continue.getBlock());
713 EmitStmt(S.getInc());
714
715 BreakContinueStack.pop_back();
716
717 EmitBranch(CondBlock);
718
719 ForScope.ForceCleanup();
720
Eric Christopher73fb3502011-10-13 21:45:18 +0000721 if (DI)
722 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
Richard Smithad762fc2011-04-14 22:09:26 +0000723
724 // Emit the fall-through block.
725 EmitBlock(LoopExit.getBlock(), true);
726}
727
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +0000728void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) {
729 if (RV.isScalar()) {
730 Builder.CreateStore(RV.getScalarVal(), ReturnValue);
731 } else if (RV.isAggregate()) {
732 EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty);
733 } else {
734 StoreComplexToAddr(RV.getComplexVal(), ReturnValue, false);
735 }
Anders Carlsson82d8ef02009-02-09 20:31:03 +0000736 EmitBranchThroughCleanup(ReturnBlock);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +0000737}
738
Reid Spencer5f016e22007-07-11 17:01:13 +0000739/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand
740/// if the function returns void, or may be missing one if the function returns
741/// non-void. Fun stuff :).
742void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000743 // Emit the result value, even if unused, to evalute the side effects.
744 const Expr *RV = S.getRetValue();
Mike Stump1eb44332009-09-09 15:08:12 +0000745
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000746 // FIXME: Clean this up by using an LValue for ReturnTemp,
747 // EmitStoreThroughLValue, and EmitAnyExpr.
Douglas Gregord86c4772010-05-15 06:46:45 +0000748 if (S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable() &&
749 !Target.useGlobalsForAutomaticVariables()) {
750 // Apply the named return value optimization for this return statement,
751 // which means doing nothing: the appropriate result has already been
752 // constructed into the NRVO variable.
Douglas Gregor3d91bbc2010-05-17 15:52:46 +0000753
754 // If there is an NRVO flag for this variable, set it to 1 into indicate
755 // that the cleanup code should not destroy the variable.
John McCalld16c2cf2011-02-08 08:22:06 +0000756 if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()])
757 Builder.CreateStore(Builder.getTrue(), NRVOFlag);
Douglas Gregord86c4772010-05-15 06:46:45 +0000758 } else if (!ReturnValue) {
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000759 // Make sure not to return anything, but evaluate the expression
760 // for side effects.
761 if (RV)
Eli Friedman144ac612008-05-22 01:22:33 +0000762 EmitAnyExpr(RV);
Reid Spencer5f016e22007-07-11 17:01:13 +0000763 } else if (RV == 0) {
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000764 // Do nothing (return value is left uninitialized)
Eli Friedmand54b6ac2009-05-27 04:56:12 +0000765 } else if (FnRetTy->isReferenceType()) {
766 // If this function returns a reference, take the address of the expression
767 // rather than the value.
Anders Carlsson32f36ba2010-06-26 16:35:32 +0000768 RValue Result = EmitReferenceBindingToExpr(RV, /*InitializedDecl=*/0);
Douglas Gregor33fd1fc2010-03-24 23:14:04 +0000769 Builder.CreateStore(Result.getScalarVal(), ReturnValue);
Chris Lattner4b0029d2007-08-26 07:14:44 +0000770 } else if (!hasAggregateLLVMType(RV->getType())) {
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000771 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue);
Chris Lattner9b2dc282008-04-04 16:54:41 +0000772 } else if (RV->getType()->isAnyComplexType()) {
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000773 EmitComplexExprIntoAddr(RV, ReturnValue, false);
Reid Spencer5f016e22007-07-11 17:01:13 +0000774 } else {
Eli Friedmand7722d92011-12-03 02:13:40 +0000775 CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType());
Eli Friedmanf3940782011-12-03 00:54:26 +0000776 EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment, Qualifiers(),
John McCall7c2349b2011-08-25 20:40:09 +0000777 AggValueSlot::IsDestructed,
John McCall410ffb22011-08-25 23:04:34 +0000778 AggValueSlot::DoesNotNeedGCBarriers,
779 AggValueSlot::IsNotAliased));
Reid Spencer5f016e22007-07-11 17:01:13 +0000780 }
Eli Friedman144ac612008-05-22 01:22:33 +0000781
Anders Carlsson82d8ef02009-02-09 20:31:03 +0000782 EmitBranchThroughCleanup(ReturnBlock);
Reid Spencer5f016e22007-07-11 17:01:13 +0000783}
784
785void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
Devang Patel91981262011-06-04 00:38:02 +0000786 // As long as debug info is modeled with instructions, we have to ensure we
787 // have a place to insert here and write the stop point here.
788 if (getDebugInfo() && HaveInsertPoint())
789 EmitStopPoint(&S);
790
Ted Kremeneke4ea1f42008-10-06 18:42:27 +0000791 for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end();
792 I != E; ++I)
793 EmitDecl(**I);
Chris Lattner6fa5f092007-07-12 15:43:07 +0000794}
Chris Lattnerda138702007-07-16 21:28:45 +0000795
Daniel Dunbar09124252008-11-12 08:21:33 +0000796void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) {
Chris Lattnerda138702007-07-16 21:28:45 +0000797 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
798
Daniel Dunbar09124252008-11-12 08:21:33 +0000799 // If this code is reachable then emit a stop point (if generating
800 // debug info). We have to do this ourselves because we are on the
801 // "simple" statement path.
802 if (HaveInsertPoint())
803 EmitStopPoint(&S);
Mike Stumpec9771d2009-02-08 09:22:19 +0000804
John McCallf1549f62010-07-06 01:34:17 +0000805 JumpDest Block = BreakContinueStack.back().BreakBlock;
Anders Carlsson82d8ef02009-02-09 20:31:03 +0000806 EmitBranchThroughCleanup(Block);
Chris Lattnerda138702007-07-16 21:28:45 +0000807}
808
Daniel Dunbar09124252008-11-12 08:21:33 +0000809void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) {
Chris Lattnerda138702007-07-16 21:28:45 +0000810 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
811
Daniel Dunbar09124252008-11-12 08:21:33 +0000812 // If this code is reachable then emit a stop point (if generating
813 // debug info). We have to do this ourselves because we are on the
814 // "simple" statement path.
815 if (HaveInsertPoint())
816 EmitStopPoint(&S);
Mike Stumpec9771d2009-02-08 09:22:19 +0000817
John McCallf1549f62010-07-06 01:34:17 +0000818 JumpDest Block = BreakContinueStack.back().ContinueBlock;
Anders Carlsson82d8ef02009-02-09 20:31:03 +0000819 EmitBranchThroughCleanup(Block);
Chris Lattnerda138702007-07-16 21:28:45 +0000820}
Devang Patel51b09f22007-10-04 23:45:31 +0000821
Devang Patelc049e4f2007-10-08 20:57:48 +0000822/// EmitCaseStmtRange - If case statement range is not too big then
823/// add multiple cases to switch instruction, one for each value within
824/// the range. If range is too big then emit "if" condition check.
825void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
Daniel Dunbar4efde8d2008-07-24 01:18:41 +0000826 assert(S.getRHS() && "Expected RHS value in CaseStmt");
Devang Patelc049e4f2007-10-08 20:57:48 +0000827
Richard Smitha6b8b2c2011-10-10 18:28:20 +0000828 llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext());
829 llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext());
Daniel Dunbar4efde8d2008-07-24 01:18:41 +0000830
Daniel Dunbar16f23572008-07-25 01:11:38 +0000831 // Emit the code for this case. We do this first to make sure it is
832 // properly chained from our predecessor before generating the
833 // switch machinery to enter this block.
Daniel Dunbarf84dcda2008-11-11 04:12:31 +0000834 EmitBlock(createBasicBlock("sw.bb"));
Daniel Dunbar16f23572008-07-25 01:11:38 +0000835 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
836 EmitStmt(S.getSubStmt());
837
Daniel Dunbar4efde8d2008-07-24 01:18:41 +0000838 // If range is empty, do nothing.
839 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
840 return;
Devang Patelc049e4f2007-10-08 20:57:48 +0000841
842 llvm::APInt Range = RHS - LHS;
Daniel Dunbar16f23572008-07-25 01:11:38 +0000843 // FIXME: parameters such as this should not be hardcoded.
Devang Patelc049e4f2007-10-08 20:57:48 +0000844 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
845 // Range is small enough to add multiple switch instruction cases.
Daniel Dunbar4efde8d2008-07-24 01:18:41 +0000846 for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) {
Chris Lattner97d54372011-04-19 20:53:45 +0000847 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest);
Devang Patel2d79d0f2007-10-05 20:54:07 +0000848 LHS++;
849 }
Devang Patelc049e4f2007-10-08 20:57:48 +0000850 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000851 }
852
Daniel Dunbar16f23572008-07-25 01:11:38 +0000853 // The range is too big. Emit "if" condition into a new block,
854 // making sure to save and restore the current insertion point.
855 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
Devang Patel2d79d0f2007-10-05 20:54:07 +0000856
Daniel Dunbar16f23572008-07-25 01:11:38 +0000857 // Push this test onto the chain of range checks (which terminates
858 // in the default basic block). The switch's default will be changed
859 // to the top of this chain after switch emission is complete.
860 llvm::BasicBlock *FalseDest = CaseRangeBlock;
Daniel Dunbar55e87422008-11-11 02:29:29 +0000861 CaseRangeBlock = createBasicBlock("sw.caserange");
Devang Patelc049e4f2007-10-08 20:57:48 +0000862
Daniel Dunbar16f23572008-07-25 01:11:38 +0000863 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
864 Builder.SetInsertPoint(CaseRangeBlock);
Devang Patelc049e4f2007-10-08 20:57:48 +0000865
866 // Emit range check.
Mike Stump1eb44332009-09-09 15:08:12 +0000867 llvm::Value *Diff =
Benjamin Kramer578faa82011-09-27 21:06:10 +0000868 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
Mike Stump1eb44332009-09-09 15:08:12 +0000869 llvm::Value *Cond =
Chris Lattner97d54372011-04-19 20:53:45 +0000870 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
Devang Patelc049e4f2007-10-08 20:57:48 +0000871 Builder.CreateCondBr(Cond, CaseDest, FalseDest);
872
Daniel Dunbar16f23572008-07-25 01:11:38 +0000873 // Restore the appropriate insertion point.
Daniel Dunbara448fb22008-11-11 23:11:34 +0000874 if (RestoreBB)
875 Builder.SetInsertPoint(RestoreBB);
876 else
877 Builder.ClearInsertionPoint();
Devang Patelc049e4f2007-10-08 20:57:48 +0000878}
879
880void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) {
Fariborz Jahaniand66715d2012-01-16 17:35:57 +0000881 // If there is no enclosing switch instance that we're aware of, then this
882 // case statement and its block can be elided. This situation only happens
883 // when we've constant-folded the switch, are emitting the constant case,
884 // and part of the constant case includes another case statement. For
885 // instance: switch (4) { case 4: do { case 5: } while (1); }
Fariborz Jahanian303b4f92012-01-17 23:55:19 +0000886 if (!SwitchInsn) {
887 EmitStmt(S.getSubStmt());
Fariborz Jahaniand66715d2012-01-16 17:35:57 +0000888 return;
Fariborz Jahanian303b4f92012-01-17 23:55:19 +0000889 }
Fariborz Jahaniand66715d2012-01-16 17:35:57 +0000890
Chris Lattnerb11f9192011-04-17 00:54:30 +0000891 // Handle case ranges.
Devang Patelc049e4f2007-10-08 20:57:48 +0000892 if (S.getRHS()) {
893 EmitCaseStmtRange(S);
894 return;
895 }
Mike Stump1eb44332009-09-09 15:08:12 +0000896
Chris Lattner97d54372011-04-19 20:53:45 +0000897 llvm::ConstantInt *CaseVal =
Richard Smitha6b8b2c2011-10-10 18:28:20 +0000898 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
Chris Lattner97d54372011-04-19 20:53:45 +0000899
Chris Lattner42104862011-04-17 23:21:26 +0000900 // If the body of the case is just a 'break', and if there was no fallthrough,
901 // try to not emit an empty block.
Chris Lattnerb11f9192011-04-17 00:54:30 +0000902 if (isa<BreakStmt>(S.getSubStmt())) {
903 JumpDest Block = BreakContinueStack.back().BreakBlock;
904
905 // Only do this optimization if there are no cleanups that need emitting.
906 if (isObviouslyBranchWithoutCleanups(Block)) {
Chris Lattner97d54372011-04-19 20:53:45 +0000907 SwitchInsn->addCase(CaseVal, Block.getBlock());
Chris Lattner42104862011-04-17 23:21:26 +0000908
909 // If there was a fallthrough into this case, make sure to redirect it to
910 // the end of the switch as well.
911 if (Builder.GetInsertBlock()) {
912 Builder.CreateBr(Block.getBlock());
913 Builder.ClearInsertionPoint();
914 }
Chris Lattnerb11f9192011-04-17 00:54:30 +0000915 return;
916 }
917 }
918
Daniel Dunbarf84dcda2008-11-11 04:12:31 +0000919 EmitBlock(createBasicBlock("sw.bb"));
Devang Patelc049e4f2007-10-08 20:57:48 +0000920 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
Chris Lattner97d54372011-04-19 20:53:45 +0000921 SwitchInsn->addCase(CaseVal, CaseDest);
Mike Stump1eb44332009-09-09 15:08:12 +0000922
Chris Lattner5512f282009-03-04 04:46:18 +0000923 // Recursively emitting the statement is acceptable, but is not wonderful for
924 // code where we have many case statements nested together, i.e.:
925 // case 1:
926 // case 2:
927 // case 3: etc.
928 // Handling this recursively will create a new block for each case statement
929 // that falls through to the next case which is IR intensive. It also causes
930 // deep recursion which can run into stack depth limitations. Handle
931 // sequential non-range case statements specially.
932 const CaseStmt *CurCase = &S;
933 const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt());
934
Chris Lattner97d54372011-04-19 20:53:45 +0000935 // Otherwise, iteratively add consecutive cases to this switch stmt.
Chris Lattner5512f282009-03-04 04:46:18 +0000936 while (NextCase && NextCase->getRHS() == 0) {
937 CurCase = NextCase;
Chris Lattner97d54372011-04-19 20:53:45 +0000938 llvm::ConstantInt *CaseVal =
Richard Smitha6b8b2c2011-10-10 18:28:20 +0000939 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
Chris Lattner97d54372011-04-19 20:53:45 +0000940 SwitchInsn->addCase(CaseVal, CaseDest);
Chris Lattner5512f282009-03-04 04:46:18 +0000941 NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt());
942 }
Mike Stump1eb44332009-09-09 15:08:12 +0000943
Chris Lattner5512f282009-03-04 04:46:18 +0000944 // Normal default recursion for non-cases.
945 EmitStmt(CurCase->getSubStmt());
Devang Patel51b09f22007-10-04 23:45:31 +0000946}
947
948void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {
Daniel Dunbar16f23572008-07-25 01:11:38 +0000949 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
Mike Stump1eb44332009-09-09 15:08:12 +0000950 assert(DefaultBlock->empty() &&
Daniel Dunbar55e87422008-11-11 02:29:29 +0000951 "EmitDefaultStmt: Default block already defined?");
Daniel Dunbar16f23572008-07-25 01:11:38 +0000952 EmitBlock(DefaultBlock);
Devang Patel51b09f22007-10-04 23:45:31 +0000953 EmitStmt(S.getSubStmt());
954}
955
Chris Lattnerfda0f1f2011-02-28 00:22:07 +0000956/// CollectStatementsForCase - Given the body of a 'switch' statement and a
957/// constant value that is being switched on, see if we can dead code eliminate
958/// the body of the switch to a simple series of statements to emit. Basically,
959/// on a switch (5) we want to find these statements:
960/// case 5:
961/// printf(...); <--
962/// ++i; <--
963/// break;
964///
965/// and add them to the ResultStmts vector. If it is unsafe to do this
966/// transformation (for example, one of the elided statements contains a label
967/// that might be jumped to), return CSFC_Failure. If we handled it and 'S'
968/// should include statements after it (e.g. the printf() line is a substmt of
969/// the case) then return CSFC_FallThrough. If we handled it and found a break
970/// statement, then return CSFC_Success.
971///
972/// If Case is non-null, then we are looking for the specified case, checking
973/// that nothing we jump over contains labels. If Case is null, then we found
974/// the case and are looking for the break.
975///
976/// If the recursive walk actually finds our Case, then we set FoundCase to
977/// true.
978///
979enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success };
980static CSFC_Result CollectStatementsForCase(const Stmt *S,
981 const SwitchCase *Case,
982 bool &FoundCase,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000983 SmallVectorImpl<const Stmt*> &ResultStmts) {
Chris Lattner38589382011-02-28 01:02:29 +0000984 // If this is a null statement, just succeed.
985 if (S == 0)
986 return Case ? CSFC_Success : CSFC_FallThrough;
987
Chris Lattnerfda0f1f2011-02-28 00:22:07 +0000988 // If this is the switchcase (case 4: or default) that we're looking for, then
989 // we're in business. Just add the substatement.
990 if (const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
991 if (S == Case) {
992 FoundCase = true;
993 return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase,
994 ResultStmts);
995 }
996
997 // Otherwise, this is some other case or default statement, just ignore it.
998 return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase,
999 ResultStmts);
1000 }
Chris Lattner38589382011-02-28 01:02:29 +00001001
1002 // If we are in the live part of the code and we found our break statement,
1003 // return a success!
1004 if (Case == 0 && isa<BreakStmt>(S))
1005 return CSFC_Success;
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001006
Chris Lattner38589382011-02-28 01:02:29 +00001007 // If this is a switch statement, then it might contain the SwitchCase, the
1008 // break, or neither.
1009 if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1010 // Handle this as two cases: we might be looking for the SwitchCase (if so
1011 // the skipped statements must be skippable) or we might already have it.
1012 CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end();
1013 if (Case) {
Chris Lattner3f06e272011-02-28 07:22:44 +00001014 // Keep track of whether we see a skipped declaration. The code could be
1015 // using the declaration even if it is skipped, so we can't optimize out
1016 // the decl if the kept statements might refer to it.
1017 bool HadSkippedDecl = false;
1018
Chris Lattner38589382011-02-28 01:02:29 +00001019 // If we're looking for the case, just see if we can skip each of the
1020 // substatements.
1021 for (; Case && I != E; ++I) {
Eli Friedman4d509342011-05-21 19:15:39 +00001022 HadSkippedDecl |= isa<DeclStmt>(*I);
Chris Lattner3f06e272011-02-28 07:22:44 +00001023
Chris Lattner38589382011-02-28 01:02:29 +00001024 switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) {
1025 case CSFC_Failure: return CSFC_Failure;
1026 case CSFC_Success:
1027 // A successful result means that either 1) that the statement doesn't
1028 // have the case and is skippable, or 2) does contain the case value
Chris Lattner94671102011-02-28 07:16:14 +00001029 // and also contains the break to exit the switch. In the later case,
1030 // we just verify the rest of the statements are elidable.
1031 if (FoundCase) {
Chris Lattner3f06e272011-02-28 07:22:44 +00001032 // If we found the case and skipped declarations, we can't do the
1033 // optimization.
1034 if (HadSkippedDecl)
1035 return CSFC_Failure;
1036
Chris Lattner94671102011-02-28 07:16:14 +00001037 for (++I; I != E; ++I)
1038 if (CodeGenFunction::ContainsLabel(*I, true))
1039 return CSFC_Failure;
1040 return CSFC_Success;
1041 }
Chris Lattner38589382011-02-28 01:02:29 +00001042 break;
1043 case CSFC_FallThrough:
1044 // If we have a fallthrough condition, then we must have found the
1045 // case started to include statements. Consider the rest of the
1046 // statements in the compound statement as candidates for inclusion.
1047 assert(FoundCase && "Didn't find case but returned fallthrough?");
1048 // We recursively found Case, so we're not looking for it anymore.
1049 Case = 0;
Chris Lattner3f06e272011-02-28 07:22:44 +00001050
1051 // If we found the case and skipped declarations, we can't do the
1052 // optimization.
1053 if (HadSkippedDecl)
1054 return CSFC_Failure;
Chris Lattner38589382011-02-28 01:02:29 +00001055 break;
1056 }
1057 }
1058 }
1059
1060 // If we have statements in our range, then we know that the statements are
1061 // live and need to be added to the set of statements we're tracking.
1062 for (; I != E; ++I) {
1063 switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) {
1064 case CSFC_Failure: return CSFC_Failure;
1065 case CSFC_FallThrough:
1066 // A fallthrough result means that the statement was simple and just
1067 // included in ResultStmt, keep adding them afterwards.
1068 break;
1069 case CSFC_Success:
1070 // A successful result means that we found the break statement and
1071 // stopped statement inclusion. We just ensure that any leftover stmts
1072 // are skippable and return success ourselves.
1073 for (++I; I != E; ++I)
1074 if (CodeGenFunction::ContainsLabel(*I, true))
1075 return CSFC_Failure;
1076 return CSFC_Success;
1077 }
1078 }
1079
1080 return Case ? CSFC_Success : CSFC_FallThrough;
1081 }
1082
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001083 // Okay, this is some other statement that we don't handle explicitly, like a
1084 // for statement or increment etc. If we are skipping over this statement,
1085 // just verify it doesn't have labels, which would make it invalid to elide.
1086 if (Case) {
Chris Lattner3f06e272011-02-28 07:22:44 +00001087 if (CodeGenFunction::ContainsLabel(S, true))
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001088 return CSFC_Failure;
1089 return CSFC_Success;
1090 }
1091
1092 // Otherwise, we want to include this statement. Everything is cool with that
1093 // so long as it doesn't contain a break out of the switch we're in.
1094 if (CodeGenFunction::containsBreak(S)) return CSFC_Failure;
1095
1096 // Otherwise, everything is great. Include the statement and tell the caller
1097 // that we fall through and include the next statement as well.
1098 ResultStmts.push_back(S);
1099 return CSFC_FallThrough;
1100}
1101
1102/// FindCaseStatementsForValue - Find the case statement being jumped to and
1103/// then invoke CollectStatementsForCase to find the list of statements to emit
1104/// for a switch on constant. See the comment above CollectStatementsForCase
1105/// for more details.
1106static bool FindCaseStatementsForValue(const SwitchStmt &S,
1107 const llvm::APInt &ConstantCondValue,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001108 SmallVectorImpl<const Stmt*> &ResultStmts,
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001109 ASTContext &C) {
1110 // First step, find the switch case that is being branched to. We can do this
1111 // efficiently by scanning the SwitchCase list.
1112 const SwitchCase *Case = S.getSwitchCaseList();
1113 const DefaultStmt *DefaultCase = 0;
1114
1115 for (; Case; Case = Case->getNextSwitchCase()) {
1116 // It's either a default or case. Just remember the default statement in
1117 // case we're not jumping to any numbered cases.
1118 if (const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1119 DefaultCase = DS;
1120 continue;
1121 }
1122
1123 // Check to see if this case is the one we're looking for.
1124 const CaseStmt *CS = cast<CaseStmt>(Case);
1125 // Don't handle case ranges yet.
1126 if (CS->getRHS()) return false;
1127
1128 // If we found our case, remember it as 'case'.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001129 if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue)
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001130 break;
1131 }
1132
1133 // If we didn't find a matching case, we use a default if it exists, or we
1134 // elide the whole switch body!
1135 if (Case == 0) {
1136 // It is safe to elide the body of the switch if it doesn't contain labels
1137 // etc. If it is safe, return successfully with an empty ResultStmts list.
1138 if (DefaultCase == 0)
1139 return !CodeGenFunction::ContainsLabel(&S);
1140 Case = DefaultCase;
1141 }
1142
1143 // Ok, we know which case is being jumped to, try to collect all the
1144 // statements that follow it. This can fail for a variety of reasons. Also,
1145 // check to see that the recursive walk actually found our case statement.
1146 // Insane cases like this can fail to find it in the recursive walk since we
1147 // don't handle every stmt kind:
1148 // switch (4) {
1149 // while (1) {
1150 // case 4: ...
1151 bool FoundCase = false;
1152 return CollectStatementsForCase(S.getBody(), Case, FoundCase,
1153 ResultStmts) != CSFC_Failure &&
1154 FoundCase;
1155}
1156
Devang Patel51b09f22007-10-04 23:45:31 +00001157void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) {
John McCallf1549f62010-07-06 01:34:17 +00001158 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog");
1159
1160 RunCleanupsScope ConditionScope(*this);
Douglas Gregord3d53012009-11-24 17:07:59 +00001161
1162 if (S.getConditionVariable())
John McCallb6bbcc92010-10-15 04:57:14 +00001163 EmitAutoVarDecl(*S.getConditionVariable());
Douglas Gregord3d53012009-11-24 17:07:59 +00001164
Fariborz Jahanian985df1c2012-01-17 23:39:50 +00001165 // Handle nested switch statements.
1166 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1167 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1168
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001169 // See if we can constant fold the condition of the switch and therefore only
1170 // emit the live case statement (if any) of the switch.
1171 llvm::APInt ConstantCondValue;
1172 if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001173 SmallVector<const Stmt*, 4> CaseStmts;
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001174 if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts,
1175 getContext())) {
1176 RunCleanupsScope ExecutedScope(*this);
1177
Fariborz Jahanian985df1c2012-01-17 23:39:50 +00001178 // At this point, we are no longer "within" a switch instance, so
1179 // we can temporarily enforce this to ensure that any embedded case
1180 // statements are not emitted.
1181 SwitchInsn = 0;
1182
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001183 // Okay, we can dead code eliminate everything except this case. Emit the
1184 // specified series of statements and we're good.
1185 for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1186 EmitStmt(CaseStmts[i]);
Fariborz Jahanian985df1c2012-01-17 23:39:50 +00001187
1188 // Now we want to restore the saved switch instance so that nested switches
1189 // continue to function properly
1190 SwitchInsn = SavedSwitchInsn;
1191
Chris Lattnerfda0f1f2011-02-28 00:22:07 +00001192 return;
1193 }
1194 }
1195
Devang Patel51b09f22007-10-04 23:45:31 +00001196 llvm::Value *CondV = EmitScalarExpr(S.getCond());
1197
Daniel Dunbar16f23572008-07-25 01:11:38 +00001198 // Create basic block to hold stuff that comes after switch
1199 // statement. We also need to create a default block now so that
1200 // explicit case ranges tests can have a place to jump to on
1201 // failure.
Daniel Dunbar55e87422008-11-11 02:29:29 +00001202 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default");
Daniel Dunbar16f23572008-07-25 01:11:38 +00001203 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
1204 CaseRangeBlock = DefaultBlock;
Devang Patel51b09f22007-10-04 23:45:31 +00001205
Daniel Dunbar09124252008-11-12 08:21:33 +00001206 // Clear the insertion point to indicate we are in unreachable code.
1207 Builder.ClearInsertionPoint();
Eli Friedmand28a80d2008-05-12 16:08:04 +00001208
Devang Patele9b8c0a2007-10-30 20:59:40 +00001209 // All break statements jump to NextBlock. If BreakContinueStack is non empty
1210 // then reuse last ContinueBlock.
John McCallf1549f62010-07-06 01:34:17 +00001211 JumpDest OuterContinue;
Anders Carlssone4b6d342009-02-10 05:52:02 +00001212 if (!BreakContinueStack.empty())
John McCallf1549f62010-07-06 01:34:17 +00001213 OuterContinue = BreakContinueStack.back().ContinueBlock;
Anders Carlssone4b6d342009-02-10 05:52:02 +00001214
John McCallf1549f62010-07-06 01:34:17 +00001215 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
Devang Patel51b09f22007-10-04 23:45:31 +00001216
1217 // Emit switch body.
1218 EmitStmt(S.getBody());
Mike Stump1eb44332009-09-09 15:08:12 +00001219
Anders Carlssone4b6d342009-02-10 05:52:02 +00001220 BreakContinueStack.pop_back();
Devang Patel51b09f22007-10-04 23:45:31 +00001221
Daniel Dunbar16f23572008-07-25 01:11:38 +00001222 // Update the default block in case explicit case range tests have
1223 // been chained on top.
1224 SwitchInsn->setSuccessor(0, CaseRangeBlock);
Mike Stump1eb44332009-09-09 15:08:12 +00001225
John McCallf1549f62010-07-06 01:34:17 +00001226 // If a default was never emitted:
Daniel Dunbar16f23572008-07-25 01:11:38 +00001227 if (!DefaultBlock->getParent()) {
John McCallf1549f62010-07-06 01:34:17 +00001228 // If we have cleanups, emit the default block so that there's a
1229 // place to jump through the cleanups from.
1230 if (ConditionScope.requiresCleanups()) {
1231 EmitBlock(DefaultBlock);
1232
1233 // Otherwise, just forward the default block to the switch end.
1234 } else {
John McCallff8e1152010-07-23 21:56:41 +00001235 DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock());
John McCallf1549f62010-07-06 01:34:17 +00001236 delete DefaultBlock;
1237 }
Daniel Dunbar16f23572008-07-25 01:11:38 +00001238 }
Devang Patel51b09f22007-10-04 23:45:31 +00001239
John McCallff8e1152010-07-23 21:56:41 +00001240 ConditionScope.ForceCleanup();
1241
Daniel Dunbar16f23572008-07-25 01:11:38 +00001242 // Emit continuation.
John McCallff8e1152010-07-23 21:56:41 +00001243 EmitBlock(SwitchExit.getBlock(), true);
Daniel Dunbar16f23572008-07-25 01:11:38 +00001244
Devang Patel51b09f22007-10-04 23:45:31 +00001245 SwitchInsn = SavedSwitchInsn;
Devang Patelc049e4f2007-10-08 20:57:48 +00001246 CaseRangeBlock = SavedCRBlock;
Devang Patel51b09f22007-10-04 23:45:31 +00001247}
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001248
Chris Lattner2819fa82009-04-26 17:57:12 +00001249static std::string
Daniel Dunbar444be732009-11-13 05:51:54 +00001250SimplifyConstraint(const char *Constraint, const TargetInfo &Target,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001251 SmallVectorImpl<TargetInfo::ConstraintInfo> *OutCons=0) {
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001252 std::string Result;
Mike Stump1eb44332009-09-09 15:08:12 +00001253
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001254 while (*Constraint) {
1255 switch (*Constraint) {
1256 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001257 Result += Target.convertConstraint(Constraint);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001258 break;
1259 // Ignore these
1260 case '*':
1261 case '?':
1262 case '!':
John Thompsonef44e112010-08-10 19:20:14 +00001263 case '=': // Will see this and the following in mult-alt constraints.
1264 case '+':
1265 break;
John Thompson2f474ea2010-09-18 01:15:13 +00001266 case ',':
1267 Result += "|";
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001268 break;
1269 case 'g':
1270 Result += "imr";
1271 break;
Anders Carlsson300fb5d2009-01-18 02:06:20 +00001272 case '[': {
Chris Lattner2819fa82009-04-26 17:57:12 +00001273 assert(OutCons &&
Anders Carlsson300fb5d2009-01-18 02:06:20 +00001274 "Must pass output names to constraints with a symbolic name");
1275 unsigned Index;
Mike Stump1eb44332009-09-09 15:08:12 +00001276 bool result = Target.resolveSymbolicName(Constraint,
Chris Lattner2819fa82009-04-26 17:57:12 +00001277 &(*OutCons)[0],
1278 OutCons->size(), Index);
Chris Lattnercbf40f92011-01-05 18:41:53 +00001279 assert(result && "Could not resolve symbolic name"); (void)result;
Anders Carlsson300fb5d2009-01-18 02:06:20 +00001280 Result += llvm::utostr(Index);
1281 break;
1282 }
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001283 }
Mike Stump1eb44332009-09-09 15:08:12 +00001284
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001285 Constraint++;
1286 }
Mike Stump1eb44332009-09-09 15:08:12 +00001287
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001288 return Result;
1289}
1290
Rafael Espindola03117d12011-01-01 21:12:33 +00001291/// AddVariableConstraints - Look at AsmExpr and if it is a variable declared
1292/// as using a particular register add that as a constraint that will be used
1293/// in this asm stmt.
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001294static std::string
Rafael Espindola03117d12011-01-01 21:12:33 +00001295AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
1296 const TargetInfo &Target, CodeGenModule &CGM,
1297 const AsmStmt &Stmt) {
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001298 const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);
1299 if (!AsmDeclRef)
1300 return Constraint;
1301 const ValueDecl &Value = *AsmDeclRef->getDecl();
1302 const VarDecl *Variable = dyn_cast<VarDecl>(&Value);
1303 if (!Variable)
1304 return Constraint;
1305 AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>();
1306 if (!Attr)
1307 return Constraint;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001308 StringRef Register = Attr->getLabel();
Rafael Espindolabaf86952011-01-01 21:47:03 +00001309 assert(Target.isValidGCCRegisterName(Register));
Eric Christophere3e07a52011-06-17 01:53:34 +00001310 // We're using validateOutputConstraint here because we only care if
1311 // this is a register constraint.
1312 TargetInfo::ConstraintInfo Info(Constraint, "");
1313 if (Target.validateOutputConstraint(Info) &&
1314 !Info.allowsRegister()) {
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001315 CGM.ErrorUnsupported(&Stmt, "__asm__");
1316 return Constraint;
1317 }
Eric Christopher43fec872011-06-21 00:07:10 +00001318 // Canonicalize the register here before returning it.
1319 Register = Target.getNormalizedGCCRegisterName(Register);
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001320 return "{" + Register.str() + "}";
1321}
1322
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001323llvm::Value*
1324CodeGenFunction::EmitAsmInputLValue(const AsmStmt &S,
1325 const TargetInfo::ConstraintInfo &Info,
1326 LValue InputValue, QualType InputType,
1327 std::string &ConstraintStr) {
Anders Carlsson63471722009-01-11 19:32:54 +00001328 llvm::Value *Arg;
Mike Stump1eb44332009-09-09 15:08:12 +00001329 if (Info.allowsRegister() || !Info.allowsMemory()) {
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001330 if (!CodeGenFunction::hasAggregateLLVMType(InputType)) {
John McCall545d9962011-06-25 02:11:03 +00001331 Arg = EmitLoadOfLValue(InputValue).getScalarVal();
Anders Carlsson63471722009-01-11 19:32:54 +00001332 } else {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001333 llvm::Type *Ty = ConvertType(InputType);
Anders Carlssonebaae2a2009-01-12 02:22:13 +00001334 uint64_t Size = CGM.getTargetData().getTypeSizeInBits(Ty);
1335 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
John McCalld16c2cf2011-02-08 08:22:06 +00001336 Ty = llvm::IntegerType::get(getLLVMContext(), Size);
Anders Carlssonebaae2a2009-01-12 02:22:13 +00001337 Ty = llvm::PointerType::getUnqual(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00001338
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001339 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1340 Ty));
Anders Carlssonebaae2a2009-01-12 02:22:13 +00001341 } else {
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001342 Arg = InputValue.getAddress();
Anders Carlssonebaae2a2009-01-12 02:22:13 +00001343 ConstraintStr += '*';
1344 }
Anders Carlsson63471722009-01-11 19:32:54 +00001345 }
1346 } else {
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001347 Arg = InputValue.getAddress();
Anders Carlsson63471722009-01-11 19:32:54 +00001348 ConstraintStr += '*';
1349 }
Mike Stump1eb44332009-09-09 15:08:12 +00001350
Anders Carlsson63471722009-01-11 19:32:54 +00001351 return Arg;
1352}
1353
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001354llvm::Value* CodeGenFunction::EmitAsmInput(const AsmStmt &S,
1355 const TargetInfo::ConstraintInfo &Info,
1356 const Expr *InputExpr,
1357 std::string &ConstraintStr) {
1358 if (Info.allowsRegister() || !Info.allowsMemory())
1359 if (!CodeGenFunction::hasAggregateLLVMType(InputExpr->getType()))
1360 return EmitScalarExpr(InputExpr);
1361
1362 InputExpr = InputExpr->IgnoreParenNoopCasts(getContext());
1363 LValue Dest = EmitLValue(InputExpr);
1364 return EmitAsmInputLValue(S, Info, Dest, InputExpr->getType(), ConstraintStr);
1365}
1366
Chris Lattner47fc7e92010-11-17 05:58:54 +00001367/// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline
Chris Lattner5d936532010-11-17 08:25:26 +00001368/// asm call instruction. The !srcloc MDNode contains a list of constant
1369/// integers which are the source locations of the start of each line in the
1370/// asm.
Chris Lattner47fc7e92010-11-17 05:58:54 +00001371static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
1372 CodeGenFunction &CGF) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001373 SmallVector<llvm::Value *, 8> Locs;
Chris Lattner5d936532010-11-17 08:25:26 +00001374 // Add the location of the first line to the MDNode.
1375 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1376 Str->getLocStart().getRawEncoding()));
Chris Lattner5f9e2722011-07-23 10:55:15 +00001377 StringRef StrVal = Str->getString();
Chris Lattner5d936532010-11-17 08:25:26 +00001378 if (!StrVal.empty()) {
1379 const SourceManager &SM = CGF.CGM.getContext().getSourceManager();
1380 const LangOptions &LangOpts = CGF.CGM.getLangOptions();
1381
1382 // Add the location of the start of each subsequent line of the asm to the
1383 // MDNode.
1384 for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) {
1385 if (StrVal[i] != '\n') continue;
1386 SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts,
1387 CGF.Target);
1388 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty,
1389 LineLoc.getRawEncoding()));
1390 }
1391 }
1392
Jay Foad6f141652011-04-21 19:59:12 +00001393 return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
Chris Lattner47fc7e92010-11-17 05:58:54 +00001394}
1395
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001396void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
Chris Lattner458cd9c2009-03-10 23:21:44 +00001397 // Analyze the asm string to decompose it into its pieces. We know that Sema
1398 // has already done this, so it is guaranteed to be successful.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001399 SmallVector<AsmStmt::AsmStringPiece, 4> Pieces;
Chris Lattnerfb5058e2009-03-10 23:41:04 +00001400 unsigned DiagOffs;
1401 S.AnalyzeAsmString(Pieces, getContext(), DiagOffs);
Mike Stump1eb44332009-09-09 15:08:12 +00001402
Chris Lattner458cd9c2009-03-10 23:21:44 +00001403 // Assemble the pieces into the final asm string.
1404 std::string AsmString;
1405 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
1406 if (Pieces[i].isString())
1407 AsmString += Pieces[i].getString();
1408 else if (Pieces[i].getModifier() == '\0')
1409 AsmString += '$' + llvm::utostr(Pieces[i].getOperandNo());
1410 else
1411 AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' +
1412 Pieces[i].getModifier() + '}';
Daniel Dunbar281f55c2008-10-17 20:58:01 +00001413 }
Mike Stump1eb44332009-09-09 15:08:12 +00001414
Chris Lattner481fef92009-05-03 07:05:00 +00001415 // Get all the output and input constraints together.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001416 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1417 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
Chris Lattner481fef92009-05-03 07:05:00 +00001418
Mike Stump1eb44332009-09-09 15:08:12 +00001419 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
Chris Lattner481fef92009-05-03 07:05:00 +00001420 TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i),
1421 S.getOutputName(i));
Chris Lattnerb9922592010-03-03 21:52:23 +00001422 bool IsValid = Target.validateOutputConstraint(Info); (void)IsValid;
1423 assert(IsValid && "Failed to parse output constraint");
Chris Lattner481fef92009-05-03 07:05:00 +00001424 OutputConstraintInfos.push_back(Info);
Mike Stump1eb44332009-09-09 15:08:12 +00001425 }
1426
Chris Lattner481fef92009-05-03 07:05:00 +00001427 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1428 TargetInfo::ConstraintInfo Info(S.getInputConstraint(i),
1429 S.getInputName(i));
Chris Lattnerb9922592010-03-03 21:52:23 +00001430 bool IsValid = Target.validateInputConstraint(OutputConstraintInfos.data(),
1431 S.getNumOutputs(), Info);
1432 assert(IsValid && "Failed to parse input constraint"); (void)IsValid;
Chris Lattner481fef92009-05-03 07:05:00 +00001433 InputConstraintInfos.push_back(Info);
1434 }
Mike Stump1eb44332009-09-09 15:08:12 +00001435
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001436 std::string Constraints;
Mike Stump1eb44332009-09-09 15:08:12 +00001437
Chris Lattnerede9d902009-05-03 07:53:25 +00001438 std::vector<LValue> ResultRegDests;
1439 std::vector<QualType> ResultRegQualTys;
Jay Foadef6de3d2011-07-11 09:56:20 +00001440 std::vector<llvm::Type *> ResultRegTypes;
1441 std::vector<llvm::Type *> ResultTruncRegTypes;
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001442 std::vector<llvm::Type*> ArgTypes;
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001443 std::vector<llvm::Value*> Args;
Anders Carlssonf39a4212008-02-05 20:01:53 +00001444
1445 // Keep track of inout constraints.
1446 std::string InOutConstraints;
1447 std::vector<llvm::Value*> InOutArgs;
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001448 std::vector<llvm::Type*> InOutArgTypes;
Anders Carlsson03eb5432009-01-27 20:38:24 +00001449
Mike Stump1eb44332009-09-09 15:08:12 +00001450 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
Chris Lattner481fef92009-05-03 07:05:00 +00001451 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
Anders Carlsson03eb5432009-01-27 20:38:24 +00001452
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001453 // Simplify the output constraint.
Chris Lattner481fef92009-05-03 07:05:00 +00001454 std::string OutputConstraint(S.getOutputConstraint(i));
Lauro Ramos Venancioa5694b82008-02-26 18:33:46 +00001455 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, Target);
Mike Stump1eb44332009-09-09 15:08:12 +00001456
Chris Lattner810f6d52009-03-13 17:38:01 +00001457 const Expr *OutExpr = S.getOutputExpr(i);
1458 OutExpr = OutExpr->IgnoreParenNoopCasts(getContext());
Mike Stump1eb44332009-09-09 15:08:12 +00001459
Eric Christophera18f5392011-06-03 14:52:25 +00001460 OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr,
1461 Target, CGM, S);
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001462
Chris Lattner810f6d52009-03-13 17:38:01 +00001463 LValue Dest = EmitLValue(OutExpr);
Chris Lattnerede9d902009-05-03 07:53:25 +00001464 if (!Constraints.empty())
Anders Carlssonbad3a942009-05-01 00:16:04 +00001465 Constraints += ',';
1466
Chris Lattnera077b5c2009-05-03 08:21:20 +00001467 // If this is a register output, then make the inline asm return it
1468 // by-value. If this is a memory result, return the value by-reference.
Chris Lattnerede9d902009-05-03 07:53:25 +00001469 if (!Info.allowsMemory() && !hasAggregateLLVMType(OutExpr->getType())) {
Chris Lattnera077b5c2009-05-03 08:21:20 +00001470 Constraints += "=" + OutputConstraint;
Chris Lattnerede9d902009-05-03 07:53:25 +00001471 ResultRegQualTys.push_back(OutExpr->getType());
1472 ResultRegDests.push_back(Dest);
Chris Lattnera077b5c2009-05-03 08:21:20 +00001473 ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType()));
1474 ResultTruncRegTypes.push_back(ResultRegTypes.back());
Mike Stump1eb44332009-09-09 15:08:12 +00001475
Chris Lattnera077b5c2009-05-03 08:21:20 +00001476 // If this output is tied to an input, and if the input is larger, then
1477 // we need to set the actual result type of the inline asm node to be the
1478 // same as the input type.
1479 if (Info.hasMatchingInput()) {
Chris Lattnerebfc9852009-05-03 08:38:58 +00001480 unsigned InputNo;
1481 for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) {
1482 TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo];
Chris Lattneraab64d02010-04-23 17:27:29 +00001483 if (Input.hasTiedOperand() && Input.getTiedOperand() == i)
Chris Lattnera077b5c2009-05-03 08:21:20 +00001484 break;
Chris Lattnerebfc9852009-05-03 08:38:58 +00001485 }
1486 assert(InputNo != S.getNumInputs() && "Didn't find matching input!");
Mike Stump1eb44332009-09-09 15:08:12 +00001487
Chris Lattnera077b5c2009-05-03 08:21:20 +00001488 QualType InputTy = S.getInputExpr(InputNo)->getType();
Chris Lattneraab64d02010-04-23 17:27:29 +00001489 QualType OutputType = OutExpr->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00001490
Chris Lattnera077b5c2009-05-03 08:21:20 +00001491 uint64_t InputSize = getContext().getTypeSize(InputTy);
Chris Lattneraab64d02010-04-23 17:27:29 +00001492 if (getContext().getTypeSize(OutputType) < InputSize) {
1493 // Form the asm to return the value as a larger integer or fp type.
1494 ResultRegTypes.back() = ConvertType(InputTy);
Chris Lattnera077b5c2009-05-03 08:21:20 +00001495 }
1496 }
Jay Foadef6de3d2011-07-11 09:56:20 +00001497 if (llvm::Type* AdjTy =
Peter Collingbourne4b93d662011-02-19 23:03:58 +00001498 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1499 ResultRegTypes.back()))
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001500 ResultRegTypes.back() = AdjTy;
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001501 } else {
1502 ArgTypes.push_back(Dest.getAddress()->getType());
Anders Carlssoncad3ab62008-02-05 16:57:38 +00001503 Args.push_back(Dest.getAddress());
Anders Carlssonf39a4212008-02-05 20:01:53 +00001504 Constraints += "=*";
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001505 Constraints += OutputConstraint;
Anders Carlssonf39a4212008-02-05 20:01:53 +00001506 }
Mike Stump1eb44332009-09-09 15:08:12 +00001507
Chris Lattner44def072009-04-26 07:16:29 +00001508 if (Info.isReadWrite()) {
Anders Carlssonf39a4212008-02-05 20:01:53 +00001509 InOutConstraints += ',';
Anders Carlsson63471722009-01-11 19:32:54 +00001510
Anders Carlssonfca93612009-08-04 18:18:36 +00001511 const Expr *InputExpr = S.getOutputExpr(i);
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001512 llvm::Value *Arg = EmitAsmInputLValue(S, Info, Dest, InputExpr->getType(),
1513 InOutConstraints);
Mike Stump1eb44332009-09-09 15:08:12 +00001514
Chris Lattner44def072009-04-26 07:16:29 +00001515 if (Info.allowsRegister())
Anders Carlsson9f2505b2009-01-11 21:23:27 +00001516 InOutConstraints += llvm::utostr(i);
1517 else
1518 InOutConstraints += OutputConstraint;
Anders Carlsson2763b3a2009-01-11 19:46:50 +00001519
Anders Carlssonfca93612009-08-04 18:18:36 +00001520 InOutArgTypes.push_back(Arg->getType());
1521 InOutArgs.push_back(Arg);
Anders Carlssonf39a4212008-02-05 20:01:53 +00001522 }
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001523 }
Mike Stump1eb44332009-09-09 15:08:12 +00001524
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001525 unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs();
Mike Stump1eb44332009-09-09 15:08:12 +00001526
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001527 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
1528 const Expr *InputExpr = S.getInputExpr(i);
1529
Chris Lattner481fef92009-05-03 07:05:00 +00001530 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1531
Chris Lattnerede9d902009-05-03 07:53:25 +00001532 if (!Constraints.empty())
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001533 Constraints += ',';
Mike Stump1eb44332009-09-09 15:08:12 +00001534
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001535 // Simplify the input constraint.
Chris Lattner481fef92009-05-03 07:05:00 +00001536 std::string InputConstraint(S.getInputConstraint(i));
Anders Carlsson300fb5d2009-01-18 02:06:20 +00001537 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), Target,
Chris Lattner2819fa82009-04-26 17:57:12 +00001538 &OutputConstraintInfos);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001539
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001540 InputConstraint =
Rafael Espindola03117d12011-01-01 21:12:33 +00001541 AddVariableConstraints(InputConstraint,
Rafael Espindola0ec89f92010-12-30 22:59:32 +00001542 *InputExpr->IgnoreParenNoopCasts(getContext()),
1543 Target, CGM, S);
1544
Anders Carlsson63471722009-01-11 19:32:54 +00001545 llvm::Value *Arg = EmitAsmInput(S, Info, InputExpr, Constraints);
Mike Stump1eb44332009-09-09 15:08:12 +00001546
Chris Lattner4df4ee02009-05-03 07:27:51 +00001547 // If this input argument is tied to a larger output result, extend the
1548 // input to be the same size as the output. The LLVM backend wants to see
1549 // the input and output of a matching constraint be the same size. Note
1550 // that GCC does not define what the top bits are here. We use zext because
1551 // that is usually cheaper, but LLVM IR should really get an anyext someday.
1552 if (Info.hasTiedOperand()) {
1553 unsigned Output = Info.getTiedOperand();
Chris Lattneraab64d02010-04-23 17:27:29 +00001554 QualType OutputType = S.getOutputExpr(Output)->getType();
Chris Lattner4df4ee02009-05-03 07:27:51 +00001555 QualType InputTy = InputExpr->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00001556
Chris Lattneraab64d02010-04-23 17:27:29 +00001557 if (getContext().getTypeSize(OutputType) >
Chris Lattner4df4ee02009-05-03 07:27:51 +00001558 getContext().getTypeSize(InputTy)) {
1559 // Use ptrtoint as appropriate so that we can do our extension.
1560 if (isa<llvm::PointerType>(Arg->getType()))
Chris Lattner77b89b82010-06-27 07:15:29 +00001561 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy);
Chris Lattner2acc6e32011-07-18 04:24:23 +00001562 llvm::Type *OutputTy = ConvertType(OutputType);
Chris Lattneraab64d02010-04-23 17:27:29 +00001563 if (isa<llvm::IntegerType>(OutputTy))
1564 Arg = Builder.CreateZExt(Arg, OutputTy);
Peter Collingbourne93f13222011-07-29 00:24:50 +00001565 else if (isa<llvm::PointerType>(OutputTy))
1566 Arg = Builder.CreateZExt(Arg, IntPtrTy);
1567 else {
1568 assert(OutputTy->isFloatingPointTy() && "Unexpected output type");
Chris Lattneraab64d02010-04-23 17:27:29 +00001569 Arg = Builder.CreateFPExt(Arg, OutputTy);
Peter Collingbourne93f13222011-07-29 00:24:50 +00001570 }
Chris Lattner4df4ee02009-05-03 07:27:51 +00001571 }
1572 }
Chris Lattner2acc6e32011-07-18 04:24:23 +00001573 if (llvm::Type* AdjTy =
Peter Collingbourne4b93d662011-02-19 23:03:58 +00001574 getTargetHooks().adjustInlineAsmType(*this, InputConstraint,
1575 Arg->getType()))
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001576 Arg = Builder.CreateBitCast(Arg, AdjTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001577
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001578 ArgTypes.push_back(Arg->getType());
1579 Args.push_back(Arg);
1580 Constraints += InputConstraint;
1581 }
Mike Stump1eb44332009-09-09 15:08:12 +00001582
Anders Carlssonf39a4212008-02-05 20:01:53 +00001583 // Append the "input" part of inout constraints last.
1584 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
1585 ArgTypes.push_back(InOutArgTypes[i]);
1586 Args.push_back(InOutArgs[i]);
1587 }
1588 Constraints += InOutConstraints;
Mike Stump1eb44332009-09-09 15:08:12 +00001589
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001590 // Clobbers
1591 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001592 StringRef Clobber = S.getClobber(i)->getString();
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001593
Eric Christopherde31fd72011-06-28 18:20:53 +00001594 if (Clobber != "memory" && Clobber != "cc")
Anders Carlsson83c021c2010-01-30 19:12:25 +00001595 Clobber = Target.getNormalizedGCCRegisterName(Clobber);
Mike Stump1eb44332009-09-09 15:08:12 +00001596
Anders Carlssonea041752008-02-06 00:11:32 +00001597 if (i != 0 || NumConstraints != 0)
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001598 Constraints += ',';
Mike Stump1eb44332009-09-09 15:08:12 +00001599
Anders Carlssonea041752008-02-06 00:11:32 +00001600 Constraints += "~{";
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001601 Constraints += Clobber;
Anders Carlssonea041752008-02-06 00:11:32 +00001602 Constraints += '}';
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001603 }
Mike Stump1eb44332009-09-09 15:08:12 +00001604
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001605 // Add machine specific clobbers
Eli Friedmanccf614c2008-12-21 01:15:32 +00001606 std::string MachineClobbers = Target.getClobbers();
1607 if (!MachineClobbers.empty()) {
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001608 if (!Constraints.empty())
1609 Constraints += ',';
Eli Friedmanccf614c2008-12-21 01:15:32 +00001610 Constraints += MachineClobbers;
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001611 }
Anders Carlssonbad3a942009-05-01 00:16:04 +00001612
Chris Lattner2acc6e32011-07-18 04:24:23 +00001613 llvm::Type *ResultType;
Chris Lattnera077b5c2009-05-03 08:21:20 +00001614 if (ResultRegTypes.empty())
John McCalld16c2cf2011-02-08 08:22:06 +00001615 ResultType = llvm::Type::getVoidTy(getLLVMContext());
Chris Lattnera077b5c2009-05-03 08:21:20 +00001616 else if (ResultRegTypes.size() == 1)
1617 ResultType = ResultRegTypes[0];
Anders Carlssonbad3a942009-05-01 00:16:04 +00001618 else
John McCalld16c2cf2011-02-08 08:22:06 +00001619 ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes);
Mike Stump1eb44332009-09-09 15:08:12 +00001620
Chris Lattner2acc6e32011-07-18 04:24:23 +00001621 llvm::FunctionType *FTy =
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001622 llvm::FunctionType::get(ResultType, ArgTypes, false);
Mike Stump1eb44332009-09-09 15:08:12 +00001623
1624 llvm::InlineAsm *IA =
1625 llvm::InlineAsm::get(FTy, AsmString, Constraints,
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001626 S.isVolatile() || S.getNumOutputs() == 0);
Jay Foad4c7d9f12011-07-15 08:37:34 +00001627 llvm::CallInst *Result = Builder.CreateCall(IA, Args);
Anders Carlssonbc0822b2009-03-02 19:58:15 +00001628 Result->addAttribute(~0, llvm::Attribute::NoUnwind);
Mike Stump1eb44332009-09-09 15:08:12 +00001629
Chris Lattnerfc1a9c32010-04-07 05:46:54 +00001630 // Slap the source location of the inline asm into a !srcloc metadata on the
1631 // call.
Chris Lattner47fc7e92010-11-17 05:58:54 +00001632 Result->setMetadata("srcloc", getAsmSrcLocInfo(S.getAsmString(), *this));
Mike Stump1eb44332009-09-09 15:08:12 +00001633
Chris Lattnera077b5c2009-05-03 08:21:20 +00001634 // Extract all of the register value results from the asm.
1635 std::vector<llvm::Value*> RegResults;
1636 if (ResultRegTypes.size() == 1) {
1637 RegResults.push_back(Result);
Anders Carlssonbad3a942009-05-01 00:16:04 +00001638 } else {
Chris Lattnera077b5c2009-05-03 08:21:20 +00001639 for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
Anders Carlssonbad3a942009-05-01 00:16:04 +00001640 llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult");
Chris Lattnera077b5c2009-05-03 08:21:20 +00001641 RegResults.push_back(Tmp);
Anders Carlssonbad3a942009-05-01 00:16:04 +00001642 }
1643 }
Mike Stump1eb44332009-09-09 15:08:12 +00001644
Chris Lattnera077b5c2009-05-03 08:21:20 +00001645 for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {
1646 llvm::Value *Tmp = RegResults[i];
Mike Stump1eb44332009-09-09 15:08:12 +00001647
Chris Lattnera077b5c2009-05-03 08:21:20 +00001648 // If the result type of the LLVM IR asm doesn't match the result type of
1649 // the expression, do the conversion.
1650 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001651 llvm::Type *TruncTy = ResultTruncRegTypes[i];
Chris Lattneraab64d02010-04-23 17:27:29 +00001652
1653 // Truncate the integer result to the right size, note that TruncTy can be
1654 // a pointer.
1655 if (TruncTy->isFloatingPointTy())
1656 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy);
Dan Gohman2dca88f2010-04-24 04:55:02 +00001657 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
Chris Lattneraab64d02010-04-23 17:27:29 +00001658 uint64_t ResSize = CGM.getTargetData().getTypeSizeInBits(TruncTy);
John McCalld16c2cf2011-02-08 08:22:06 +00001659 Tmp = Builder.CreateTrunc(Tmp,
1660 llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize));
Chris Lattnera077b5c2009-05-03 08:21:20 +00001661 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy);
Dan Gohman2dca88f2010-04-24 04:55:02 +00001662 } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
1663 uint64_t TmpSize =CGM.getTargetData().getTypeSizeInBits(Tmp->getType());
John McCalld16c2cf2011-02-08 08:22:06 +00001664 Tmp = Builder.CreatePtrToInt(Tmp,
1665 llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize));
Dan Gohman2dca88f2010-04-24 04:55:02 +00001666 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
1667 } else if (TruncTy->isIntegerTy()) {
1668 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001669 } else if (TruncTy->isVectorTy()) {
1670 Tmp = Builder.CreateBitCast(Tmp, TruncTy);
Chris Lattnera077b5c2009-05-03 08:21:20 +00001671 }
1672 }
Mike Stump1eb44332009-09-09 15:08:12 +00001673
John McCall545d9962011-06-25 02:11:03 +00001674 EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]);
Chris Lattnera077b5c2009-05-03 08:21:20 +00001675 }
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001676}