blob: db3f4f142dcad79aa85db7f7e5f4d704f326e0c9 [file] [log] [blame]
Chris Lattnere47e4402007-06-01 18:02:12 +00001//===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Chris Lattnere47e4402007-06-01 18:02:12 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This contains code to emit Stmt nodes as LLVM code.
10//
11//===----------------------------------------------------------------------===//
12
Chandler Carruth3a022472012-12-04 09:13:33 +000013#include "CodeGenFunction.h"
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000014#include "CGDebugInfo.h"
15#include "CodeGenModule.h"
Peter Collingbourne8f5cf742011-02-19 23:03:58 +000016#include "TargetInfo.h"
Daniel Dunbarad319a72008-08-11 05:00:27 +000017#include "clang/AST/StmtVisitor.h"
Sanjay Pateldaf34e92015-09-09 22:39:06 +000018#include "clang/Basic/Builtins.h"
Chris Lattnerff9fbca2009-03-05 08:04:57 +000019#include "clang/Basic/PrettyStackTrace.h"
Anders Carlsson952a9952008-02-05 16:35:33 +000020#include "clang/Basic/TargetInfo.h"
Anders Carlsson952a9952008-02-05 16:35:33 +000021#include "llvm/ADT/StringExtras.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000022#include "llvm/IR/DataLayout.h"
23#include "llvm/IR/InlineAsm.h"
24#include "llvm/IR/Intrinsics.h"
Sanjay Pateldaf34e92015-09-09 22:39:06 +000025#include "llvm/IR/MDBuilder.h"
26
Chris Lattnere47e4402007-06-01 18:02:12 +000027using namespace clang;
28using namespace CodeGen;
29
30//===----------------------------------------------------------------------===//
31// Statement Emission
32//===----------------------------------------------------------------------===//
33
Daniel Dunbar5fc28712008-11-12 08:21:33 +000034void CodeGenFunction::EmitStopPoint(const Stmt *S) {
Anders Carlsson63784f42009-02-13 08:11:52 +000035 if (CGDebugInfo *DI = getDebugInfo()) {
Eric Christopher7cdf9482011-10-13 21:45:18 +000036 SourceLocation Loc;
Stephen Kellyf2ceec42018-08-09 21:08:08 +000037 Loc = S->getBeginLoc();
Eric Christopher7cdf9482011-10-13 21:45:18 +000038 DI->EmitLocation(Builder, Loc);
Adrian Prantl3be10542013-05-02 17:30:20 +000039
Adrian Prantle83b1302014-01-07 22:05:52 +000040 LastStopPoint = Loc;
Daniel Dunbar5fc28712008-11-12 08:21:33 +000041 }
42}
43
Karl-Johan Karlsson33e205a2017-09-06 08:47:18 +000044void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs) {
Chris Lattnere47e4402007-06-01 18:02:12 +000045 assert(S && "Null statement?");
Bob Wilsonbf854f02014-02-17 19:21:09 +000046 PGO.setCurrentStmt(S);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +000047
Eric Christopher22e15702011-09-26 15:03:19 +000048 // These statements have their own debug info handling.
Daniel Dunbar5fc28712008-11-12 08:21:33 +000049 if (EmitSimpleStmt(S))
50 return;
51
Daniel Dunbarb6adc432009-07-19 06:58:07 +000052 // Check if we are generating unreachable code.
53 if (!HaveInsertPoint()) {
54 // If so, and the statement doesn't contain a label, then we do not need to
55 // generate actual code. This is safe because (1) the current point is
56 // unreachable, so we don't need to execute the code, and (2) we've already
57 // handled the statements which update internal data structures (like the
58 // local variable map) which could be used by subsequent statements.
59 if (!ContainsLabel(S)) {
60 // Verify that any decl statements were handled as simple, they may be in
61 // scope of subsequent reachable statements.
62 assert(!isa<DeclStmt>(*S) && "Unexpected DeclStmt!");
63 return;
64 }
65
66 // Otherwise, make a new block to hold the code.
67 EnsureInsertPoint();
68 }
69
Daniel Dunbar5fc28712008-11-12 08:21:33 +000070 // Generate a stoppoint if we are emitting debug info.
71 EmitStopPoint(S);
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000072
Alexey Bataeva8a9153a2017-12-29 18:07:07 +000073 // Ignore all OpenMP directives except for simd if OpenMP with Simd is
74 // enabled.
75 if (getLangOpts().OpenMP && getLangOpts().OpenMPSimd) {
76 if (const auto *D = dyn_cast<OMPExecutableDirective>(S)) {
77 EmitSimpleOMPExecutableDirective(*D);
78 return;
79 }
80 }
81
Chris Lattnere47e4402007-06-01 18:02:12 +000082 switch (S->getStmtClass()) {
John McCalla2342eb2010-12-05 02:00:02 +000083 case Stmt::NoStmtClass:
84 case Stmt::CXXCatchStmtClass:
John Wiegley1c0675e2011-04-28 01:08:34 +000085 case Stmt::SEHExceptStmtClass:
86 case Stmt::SEHFinallyStmtClass:
Douglas Gregordeb4a2be2011-10-25 01:33:02 +000087 case Stmt::MSDependentExistsStmtClass:
John McCalla2342eb2010-12-05 02:00:02 +000088 llvm_unreachable("invalid statement class to emit generically");
89 case Stmt::NullStmtClass:
90 case Stmt::CompoundStmtClass:
91 case Stmt::DeclStmtClass:
92 case Stmt::LabelStmtClass:
Richard Smithc202b282012-04-14 00:33:13 +000093 case Stmt::AttributedStmtClass:
John McCalla2342eb2010-12-05 02:00:02 +000094 case Stmt::GotoStmtClass:
95 case Stmt::BreakStmtClass:
96 case Stmt::ContinueStmtClass:
97 case Stmt::DefaultStmtClass:
98 case Stmt::CaseStmtClass:
Nico Weber5779f842015-02-12 23:16:11 +000099 case Stmt::SEHLeaveStmtClass:
John McCalla2342eb2010-12-05 02:00:02 +0000100 llvm_unreachable("should have emitted these statements as simple");
Daniel Dunbarc3ab4c62009-07-19 08:23:12 +0000101
John McCalla2342eb2010-12-05 02:00:02 +0000102#define STMT(Type, Base)
103#define ABSTRACT_STMT(Op)
104#define EXPR(Type, Base) \
105 case Stmt::Type##Class:
106#include "clang/AST/StmtNodes.inc"
John McCall20f6ab82011-01-12 03:41:02 +0000107 {
108 // Remember the block we came in on.
109 llvm::BasicBlock *incoming = Builder.GetInsertBlock();
110 assert(incoming && "expression emission must have an insertion point");
111
John McCalla2342eb2010-12-05 02:00:02 +0000112 EmitIgnoredExpr(cast<Expr>(S));
Mike Stump11289f42009-09-09 15:08:12 +0000113
John McCall20f6ab82011-01-12 03:41:02 +0000114 llvm::BasicBlock *outgoing = Builder.GetInsertBlock();
115 assert(outgoing && "expression emission cleared block!");
116
117 // The expression emitters assume (reasonably!) that the insertion
118 // point is always set. To maintain that, the call-emission code
119 // for noreturn functions has to enter a new block with no
120 // predecessors. We want to kill that block and mark the current
121 // insertion point unreachable in the common case of a call like
122 // "exit();". Since expression emission doesn't otherwise create
123 // blocks with no predecessors, we can just test for that.
124 // However, we must be careful not to do this to our incoming
125 // block, because *statement* emission does sometimes create
126 // reachable blocks which will have no predecessors until later in
127 // the function. This occurs with, e.g., labels that are not
128 // reachable by fallthrough.
129 if (incoming != outgoing && outgoing->use_empty()) {
130 outgoing->eraseFromParent();
131 Builder.ClearInsertionPoint();
Chris Lattnere47e4402007-06-01 18:02:12 +0000132 }
133 break;
John McCall20f6ab82011-01-12 03:41:02 +0000134 }
John McCalla2342eb2010-12-05 02:00:02 +0000135
Mike Stump11289f42009-09-09 15:08:12 +0000136 case Stmt::IndirectGotoStmtClass:
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000137 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break;
Chris Lattner946aa312007-06-05 03:59:43 +0000138
Karl-Johan Karlsson33e205a2017-09-06 08:47:18 +0000139 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break;
140 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S), Attrs); break;
141 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S), Attrs); break;
142 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S), Attrs); break;
Mike Stump11289f42009-09-09 15:08:12 +0000143
Karl-Johan Karlsson33e205a2017-09-06 08:47:18 +0000144 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break;
Daniel Dunbare23f28f2008-10-02 18:02:06 +0000145
Karl-Johan Karlsson33e205a2017-09-06 08:47:18 +0000146 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break;
147 case Stmt::GCCAsmStmtClass: // Intentional fall-through.
148 case Stmt::MSAsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break;
Richard Smith9f690bd2015-10-27 06:02:45 +0000149 case Stmt::CoroutineBodyStmtClass:
Gor Nishanov8df64e92016-10-27 16:28:31 +0000150 EmitCoroutineBody(cast<CoroutineBodyStmt>(*S));
151 break;
Richard Smith9f690bd2015-10-27 06:02:45 +0000152 case Stmt::CoreturnStmtClass:
Gor Nishanov90be1212017-03-06 21:12:54 +0000153 EmitCoreturnStmt(cast<CoreturnStmt>(*S));
Richard Smith9f690bd2015-10-27 06:02:45 +0000154 break;
Alexey Bataev758e55e2013-09-06 18:03:48 +0000155 case Stmt::CapturedStmtClass: {
156 const CapturedStmt *CS = cast<CapturedStmt>(S);
157 EmitCapturedStmt(*CS, CS->getCapturedRegionKind());
158 }
Tareq A. Siraj24110cc2013-04-16 18:53:08 +0000159 break;
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000160 case Stmt::ObjCAtTryStmtClass:
Anders Carlsson1963b0c2008-09-09 10:04:29 +0000161 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
Mike Stump11289f42009-09-09 15:08:12 +0000162 break;
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000163 case Stmt::ObjCAtCatchStmtClass:
David Blaikie83d382b2011-09-23 05:06:16 +0000164 llvm_unreachable(
165 "@catch statements should be handled by EmitObjCAtTryStmt");
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000166 case Stmt::ObjCAtFinallyStmtClass:
David Blaikie83d382b2011-09-23 05:06:16 +0000167 llvm_unreachable(
168 "@finally statements should be handled by EmitObjCAtTryStmt");
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000169 case Stmt::ObjCAtThrowStmtClass:
Anders Carlsson1963b0c2008-09-09 10:04:29 +0000170 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000171 break;
172 case Stmt::ObjCAtSynchronizedStmtClass:
Chris Lattnere132e242008-11-15 21:26:17 +0000173 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S));
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000174 break;
Mike Stump11289f42009-09-09 15:08:12 +0000175 case Stmt::ObjCForCollectionStmtClass:
Anders Carlsson2e744e82008-08-30 19:51:14 +0000176 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000177 break;
John McCall31168b02011-06-15 23:02:42 +0000178 case Stmt::ObjCAutoreleasePoolStmtClass:
179 EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S));
180 break;
Chad Rosierbebf1462012-06-20 17:43:05 +0000181
Anders Carlsson52d78a52009-09-27 18:58:34 +0000182 case Stmt::CXXTryStmtClass:
183 EmitCXXTryStmt(cast<CXXTryStmt>(*S));
184 break;
Richard Smith02e85f32011-04-14 22:09:26 +0000185 case Stmt::CXXForRangeStmtClass:
Karl-Johan Karlsson33e205a2017-09-06 08:47:18 +0000186 EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S), Attrs);
Reid Kleckner543a16c2013-09-16 21:46:30 +0000187 break;
John Wiegley1c0675e2011-04-28 01:08:34 +0000188 case Stmt::SEHTryStmtClass:
Reid Kleckner543a16c2013-09-16 21:46:30 +0000189 EmitSEHTryStmt(cast<SEHTryStmt>(*S));
Richard Smith02e85f32011-04-14 22:09:26 +0000190 break;
Alexey Bataev9959db52014-05-06 10:08:46 +0000191 case Stmt::OMPParallelDirectiveClass:
192 EmitOMPParallelDirective(cast<OMPParallelDirective>(*S));
193 break;
Alexander Musman515ad8c2014-05-22 08:54:05 +0000194 case Stmt::OMPSimdDirectiveClass:
195 EmitOMPSimdDirective(cast<OMPSimdDirective>(*S));
196 break;
Alexey Bataevf29276e2014-06-18 04:14:57 +0000197 case Stmt::OMPForDirectiveClass:
198 EmitOMPForDirective(cast<OMPForDirective>(*S));
199 break;
Alexander Musmanf82886e2014-09-18 05:12:34 +0000200 case Stmt::OMPForSimdDirectiveClass:
201 EmitOMPForSimdDirective(cast<OMPForSimdDirective>(*S));
202 break;
Alexey Bataevd3f8dd22014-06-25 11:44:49 +0000203 case Stmt::OMPSectionsDirectiveClass:
204 EmitOMPSectionsDirective(cast<OMPSectionsDirective>(*S));
205 break;
Alexey Bataev1e0498a2014-06-26 08:21:58 +0000206 case Stmt::OMPSectionDirectiveClass:
207 EmitOMPSectionDirective(cast<OMPSectionDirective>(*S));
208 break;
Alexey Bataevd1e40fb2014-06-26 12:05:45 +0000209 case Stmt::OMPSingleDirectiveClass:
210 EmitOMPSingleDirective(cast<OMPSingleDirective>(*S));
211 break;
Alexander Musman80c22892014-07-17 08:54:58 +0000212 case Stmt::OMPMasterDirectiveClass:
213 EmitOMPMasterDirective(cast<OMPMasterDirective>(*S));
214 break;
Alexander Musmand9ed09f2014-07-21 09:42:05 +0000215 case Stmt::OMPCriticalDirectiveClass:
216 EmitOMPCriticalDirective(cast<OMPCriticalDirective>(*S));
217 break;
Alexey Bataev4acb8592014-07-07 13:01:15 +0000218 case Stmt::OMPParallelForDirectiveClass:
219 EmitOMPParallelForDirective(cast<OMPParallelForDirective>(*S));
220 break;
Alexander Musmane4e893b2014-09-23 09:33:00 +0000221 case Stmt::OMPParallelForSimdDirectiveClass:
222 EmitOMPParallelForSimdDirective(cast<OMPParallelForSimdDirective>(*S));
223 break;
Alexey Bataev84d0b3e2014-07-08 08:12:03 +0000224 case Stmt::OMPParallelSectionsDirectiveClass:
225 EmitOMPParallelSectionsDirective(cast<OMPParallelSectionsDirective>(*S));
226 break;
Alexey Bataev9c2e8ee2014-07-11 11:25:16 +0000227 case Stmt::OMPTaskDirectiveClass:
228 EmitOMPTaskDirective(cast<OMPTaskDirective>(*S));
229 break;
Alexey Bataev68446b72014-07-18 07:47:19 +0000230 case Stmt::OMPTaskyieldDirectiveClass:
231 EmitOMPTaskyieldDirective(cast<OMPTaskyieldDirective>(*S));
232 break;
Alexey Bataev4d1dfea2014-07-18 09:11:51 +0000233 case Stmt::OMPBarrierDirectiveClass:
234 EmitOMPBarrierDirective(cast<OMPBarrierDirective>(*S));
235 break;
Alexey Bataev2df347a2014-07-18 10:17:07 +0000236 case Stmt::OMPTaskwaitDirectiveClass:
237 EmitOMPTaskwaitDirective(cast<OMPTaskwaitDirective>(*S));
238 break;
Alexey Bataevc30dd2d2015-06-18 12:14:09 +0000239 case Stmt::OMPTaskgroupDirectiveClass:
240 EmitOMPTaskgroupDirective(cast<OMPTaskgroupDirective>(*S));
241 break;
Alexey Bataev6125da92014-07-21 11:26:11 +0000242 case Stmt::OMPFlushDirectiveClass:
243 EmitOMPFlushDirective(cast<OMPFlushDirective>(*S));
244 break;
Alexey Bataev9fb6e642014-07-22 06:45:04 +0000245 case Stmt::OMPOrderedDirectiveClass:
246 EmitOMPOrderedDirective(cast<OMPOrderedDirective>(*S));
247 break;
Alexey Bataev0162e452014-07-22 10:10:35 +0000248 case Stmt::OMPAtomicDirectiveClass:
249 EmitOMPAtomicDirective(cast<OMPAtomicDirective>(*S));
250 break;
Alexey Bataev0bd520b2014-09-19 08:19:49 +0000251 case Stmt::OMPTargetDirectiveClass:
252 EmitOMPTargetDirective(cast<OMPTargetDirective>(*S));
253 break;
Alexey Bataev13314bf2014-10-09 04:18:56 +0000254 case Stmt::OMPTeamsDirectiveClass:
255 EmitOMPTeamsDirective(cast<OMPTeamsDirective>(*S));
256 break;
Alexey Bataev6d4ed052015-07-01 06:57:41 +0000257 case Stmt::OMPCancellationPointDirectiveClass:
258 EmitOMPCancellationPointDirective(cast<OMPCancellationPointDirective>(*S));
259 break;
Alexey Bataev80909872015-07-02 11:25:17 +0000260 case Stmt::OMPCancelDirectiveClass:
261 EmitOMPCancelDirective(cast<OMPCancelDirective>(*S));
262 break;
Michael Wong65f367f2015-07-21 13:44:28 +0000263 case Stmt::OMPTargetDataDirectiveClass:
264 EmitOMPTargetDataDirective(cast<OMPTargetDataDirective>(*S));
265 break;
Samuel Antaodf67fc42016-01-19 19:15:56 +0000266 case Stmt::OMPTargetEnterDataDirectiveClass:
267 EmitOMPTargetEnterDataDirective(cast<OMPTargetEnterDataDirective>(*S));
268 break;
Samuel Antao72590762016-01-19 20:04:50 +0000269 case Stmt::OMPTargetExitDataDirectiveClass:
270 EmitOMPTargetExitDataDirective(cast<OMPTargetExitDataDirective>(*S));
271 break;
Arpith Chacko Jacobe955b3d2016-01-26 18:48:41 +0000272 case Stmt::OMPTargetParallelDirectiveClass:
273 EmitOMPTargetParallelDirective(cast<OMPTargetParallelDirective>(*S));
274 break;
Arpith Chacko Jacob05bebb52016-02-03 15:46:42 +0000275 case Stmt::OMPTargetParallelForDirectiveClass:
276 EmitOMPTargetParallelForDirective(cast<OMPTargetParallelForDirective>(*S));
277 break;
Alexey Bataev49f6e782015-12-01 04:18:41 +0000278 case Stmt::OMPTaskLoopDirectiveClass:
279 EmitOMPTaskLoopDirective(cast<OMPTaskLoopDirective>(*S));
280 break;
Alexey Bataev0a6ed842015-12-03 09:40:15 +0000281 case Stmt::OMPTaskLoopSimdDirectiveClass:
282 EmitOMPTaskLoopSimdDirective(cast<OMPTaskLoopSimdDirective>(*S));
283 break;
Nico Weberb0dd9112016-01-28 18:06:31 +0000284 case Stmt::OMPDistributeDirectiveClass:
Carlo Bertolli6200a3d2015-12-14 14:51:25 +0000285 EmitOMPDistributeDirective(cast<OMPDistributeDirective>(*S));
Nico Weberb0dd9112016-01-28 18:06:31 +0000286 break;
Samuel Antao686c70c2016-05-26 17:30:50 +0000287 case Stmt::OMPTargetUpdateDirectiveClass:
288 EmitOMPTargetUpdateDirective(cast<OMPTargetUpdateDirective>(*S));
289 break;
Carlo Bertolli9925f152016-06-27 14:55:37 +0000290 case Stmt::OMPDistributeParallelForDirectiveClass:
291 EmitOMPDistributeParallelForDirective(
292 cast<OMPDistributeParallelForDirective>(*S));
293 break;
Kelvin Li4a39add2016-07-05 05:00:15 +0000294 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
295 EmitOMPDistributeParallelForSimdDirective(
296 cast<OMPDistributeParallelForSimdDirective>(*S));
297 break;
Kelvin Li787f3fc2016-07-06 04:45:38 +0000298 case Stmt::OMPDistributeSimdDirectiveClass:
299 EmitOMPDistributeSimdDirective(cast<OMPDistributeSimdDirective>(*S));
300 break;
Kelvin Lia579b912016-07-14 02:54:56 +0000301 case Stmt::OMPTargetParallelForSimdDirectiveClass:
302 EmitOMPTargetParallelForSimdDirective(
303 cast<OMPTargetParallelForSimdDirective>(*S));
304 break;
Kelvin Li986330c2016-07-20 22:57:10 +0000305 case Stmt::OMPTargetSimdDirectiveClass:
306 EmitOMPTargetSimdDirective(cast<OMPTargetSimdDirective>(*S));
307 break;
Kelvin Li02532872016-08-05 14:37:37 +0000308 case Stmt::OMPTeamsDistributeDirectiveClass:
309 EmitOMPTeamsDistributeDirective(cast<OMPTeamsDistributeDirective>(*S));
310 break;
Kelvin Li4e325f72016-10-25 12:50:55 +0000311 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
312 EmitOMPTeamsDistributeSimdDirective(
313 cast<OMPTeamsDistributeSimdDirective>(*S));
314 break;
Kelvin Li579e41c2016-11-30 23:51:03 +0000315 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
316 EmitOMPTeamsDistributeParallelForSimdDirective(
317 cast<OMPTeamsDistributeParallelForSimdDirective>(*S));
318 break;
Kelvin Li7ade93f2016-12-09 03:24:30 +0000319 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
320 EmitOMPTeamsDistributeParallelForDirective(
321 cast<OMPTeamsDistributeParallelForDirective>(*S));
322 break;
Kelvin Libf594a52016-12-17 05:48:59 +0000323 case Stmt::OMPTargetTeamsDirectiveClass:
324 EmitOMPTargetTeamsDirective(cast<OMPTargetTeamsDirective>(*S));
325 break;
Kelvin Li83c451e2016-12-25 04:52:54 +0000326 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
327 EmitOMPTargetTeamsDistributeDirective(
328 cast<OMPTargetTeamsDistributeDirective>(*S));
329 break;
Kelvin Li80e8f562016-12-29 22:16:30 +0000330 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
331 EmitOMPTargetTeamsDistributeParallelForDirective(
332 cast<OMPTargetTeamsDistributeParallelForDirective>(*S));
333 break;
Kelvin Li1851df52017-01-03 05:23:48 +0000334 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
335 EmitOMPTargetTeamsDistributeParallelForSimdDirective(
336 cast<OMPTargetTeamsDistributeParallelForSimdDirective>(*S));
337 break;
Kelvin Lida681182017-01-10 18:08:18 +0000338 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
339 EmitOMPTargetTeamsDistributeSimdDirective(
340 cast<OMPTargetTeamsDistributeSimdDirective>(*S));
341 break;
Chris Lattnere47e4402007-06-01 18:02:12 +0000342 }
343}
344
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000345bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
346 switch (S->getStmtClass()) {
347 default: return false;
348 case Stmt::NullStmtClass: break;
349 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
Daniel Dunbarb6adc432009-07-19 06:58:07 +0000350 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break;
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000351 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break;
Richard Smithc202b282012-04-14 00:33:13 +0000352 case Stmt::AttributedStmtClass:
353 EmitAttributedStmt(cast<AttributedStmt>(*S)); break;
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000354 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break;
355 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break;
356 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break;
357 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break;
358 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break;
Nico Weber5779f842015-02-12 23:16:11 +0000359 case Stmt::SEHLeaveStmtClass: EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S)); break;
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000360 }
361
362 return true;
363}
364
Chris Lattner04a913b2007-08-31 22:09:40 +0000365/// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true,
366/// this captures the expression result of the last sub-statement and returns it
367/// (for use by the statement expression extension).
John McCall7f416cc2015-09-08 08:05:57 +0000368Address CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
369 AggValueSlot AggSlot) {
Chris Lattnerff9fbca2009-03-05 08:04:57 +0000370 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(),
371 "LLVM IR generation of compound statement ('{}')");
Mike Stump11289f42009-09-09 15:08:12 +0000372
Eric Christopher27bc9fe2012-02-23 00:43:07 +0000373 // Keep track of the current cleanup stack depth, including debug scopes.
374 LexicalScope Scope(*this, S.getSourceRange());
Mike Stump11289f42009-09-09 15:08:12 +0000375
David Blaikie0a21d0d2013-01-26 22:16:26 +0000376 return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot);
377}
378
John McCall7f416cc2015-09-08 08:05:57 +0000379Address
Eli Friedman4871a462013-06-10 22:04:49 +0000380CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S,
381 bool GetLast,
382 AggValueSlot AggSlot) {
David Blaikie0a21d0d2013-01-26 22:16:26 +0000383
Chris Lattner04a913b2007-08-31 22:09:40 +0000384 for (CompoundStmt::const_body_iterator I = S.body_begin(),
385 E = S.body_end()-GetLast; I != E; ++I)
Chris Lattnere47e4402007-06-01 18:02:12 +0000386 EmitStmt(*I);
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000387
John McCall7f416cc2015-09-08 08:05:57 +0000388 Address RetAlloca = Address::invalid();
Eli Friedman4871a462013-06-10 22:04:49 +0000389 if (GetLast) {
Mike Stump11289f42009-09-09 15:08:12 +0000390 // We have to special case labels here. They are statements, but when put
Anders Carlsson8a472c32008-12-12 05:52:00 +0000391 // at the end of a statement expression, they yield the value of their
392 // subexpression. Handle this by walking through all labels we encounter,
393 // emitting them before we evaluate the subexpr.
394 const Stmt *LastStmt = S.body_back();
395 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000396 EmitLabel(LS->getDecl());
Anders Carlsson8a472c32008-12-12 05:52:00 +0000397 LastStmt = LS->getSubStmt();
398 }
Mike Stump11289f42009-09-09 15:08:12 +0000399
Anders Carlsson8a472c32008-12-12 05:52:00 +0000400 EnsureInsertPoint();
Mike Stump11289f42009-09-09 15:08:12 +0000401
Eli Friedman4871a462013-06-10 22:04:49 +0000402 QualType ExprTy = cast<Expr>(LastStmt)->getType();
403 if (hasAggregateEvaluationKind(ExprTy)) {
404 EmitAggExpr(cast<Expr>(LastStmt), AggSlot);
405 } else {
406 // We can't return an RValue here because there might be cleanups at
407 // the end of the StmtExpr. Because of that, we have to emit the result
408 // here into a temporary alloca.
409 RetAlloca = CreateMemTemp(ExprTy);
410 EmitAnyExprToMem(cast<Expr>(LastStmt), RetAlloca, Qualifiers(),
411 /*IsInit*/false);
412 }
Justin Bogner0f066062013-11-22 10:20:40 +0000413
Anders Carlsson8a472c32008-12-12 05:52:00 +0000414 }
415
Eli Friedman4871a462013-06-10 22:04:49 +0000416 return RetAlloca;
Chris Lattnere47e4402007-06-01 18:02:12 +0000417}
418
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000419void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) {
420 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
Mike Stump11289f42009-09-09 15:08:12 +0000421
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000422 // If there is a cleanup stack, then we it isn't worth trying to
423 // simplify this block (we would need to remove it from the scope map
424 // and cleanup entry).
John McCallbd309292010-07-06 01:34:17 +0000425 if (!EHStack.empty())
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000426 return;
427
428 // Can only simplify direct branches.
429 if (!BI || !BI->isUnconditional())
430 return;
431
Eli Friedmanfc5b2ef2012-10-26 23:23:35 +0000432 // Can only simplify empty blocks.
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +0000433 if (BI->getIterator() != BB->begin())
Eli Friedmanfc5b2ef2012-10-26 23:23:35 +0000434 return;
435
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000436 BB->replaceAllUsesWith(BI->getSuccessor(0));
437 BI->eraseFromParent();
438 BB->eraseFromParent();
439}
440
Daniel Dunbarfcac22e2008-11-13 01:24:05 +0000441void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) {
John McCallbf814c72010-04-21 11:18:06 +0000442 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
443
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000444 // Fall out of the current block (if necessary).
445 EmitBranch(BB);
Daniel Dunbarfcac22e2008-11-13 01:24:05 +0000446
447 if (IsFinished && BB->use_empty()) {
448 delete BB;
449 return;
450 }
451
John McCalle6833592010-04-21 10:29:06 +0000452 // Place the block after the current block, if possible, or else at
453 // the end of the function.
John McCallbf814c72010-04-21 11:18:06 +0000454 if (CurBB && CurBB->getParent())
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +0000455 CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB);
John McCalle6833592010-04-21 10:29:06 +0000456 else
457 CurFn->getBasicBlockList().push_back(BB);
Chris Lattnere47e4402007-06-01 18:02:12 +0000458 Builder.SetInsertPoint(BB);
459}
460
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000461void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) {
462 // Emit a branch from the current block to the target one if this
463 // was a real block. If this was just a fall-through block after a
464 // terminator, don't emit it.
465 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
466
467 if (!CurBB || CurBB->getTerminator()) {
468 // If there is no insert point or the previous block is already
469 // terminated, don't touch it.
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000470 } else {
471 // Otherwise, create a fall-through branch.
472 Builder.CreateBr(Target);
473 }
Daniel Dunbarab197eb2008-11-11 22:06:59 +0000474
475 Builder.ClearInsertionPoint();
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000476}
477
John McCall8e4c74b2011-08-11 02:22:43 +0000478void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) {
479 bool inserted = false;
Chandler Carruth4d01fff2014-03-09 03:16:50 +0000480 for (llvm::User *u : block->users()) {
481 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +0000482 CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(),
483 block);
John McCall8e4c74b2011-08-11 02:22:43 +0000484 inserted = true;
485 break;
486 }
487 }
488
489 if (!inserted)
490 CurFn->getBasicBlockList().push_back(block);
491
492 Builder.SetInsertPoint(block);
493}
494
John McCallbd309292010-07-06 01:34:17 +0000495CodeGenFunction::JumpDest
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000496CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) {
497 JumpDest &Dest = LabelMap[D];
John McCallad5d61e2010-07-23 21:56:41 +0000498 if (Dest.isValid()) return Dest;
John McCallbd309292010-07-06 01:34:17 +0000499
500 // Create, but don't insert, the new block.
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000501 Dest = JumpDest(createBasicBlock(D->getName()),
John McCallad5d61e2010-07-23 21:56:41 +0000502 EHScopeStack::stable_iterator::invalid(),
503 NextCleanupDestIndex++);
John McCallbd309292010-07-06 01:34:17 +0000504 return Dest;
505}
506
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000507void CodeGenFunction::EmitLabel(const LabelDecl *D) {
Nadav Rotem1da30942013-03-23 06:43:35 +0000508 // Add this label to the current lexical scope if we're within any
509 // normal cleanups. Jumps "in" to this label --- when permitted by
510 // the language --- may need to be routed around such cleanups.
511 if (EHStack.hasNormalCleanups() && CurLexicalScope)
512 CurLexicalScope->addLabel(D);
513
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000514 JumpDest &Dest = LabelMap[D];
John McCallbd309292010-07-06 01:34:17 +0000515
John McCallad5d61e2010-07-23 21:56:41 +0000516 // If we didn't need a forward reference to this label, just go
John McCallbd309292010-07-06 01:34:17 +0000517 // ahead and create a destination at the current scope.
John McCallad5d61e2010-07-23 21:56:41 +0000518 if (!Dest.isValid()) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000519 Dest = getJumpDestInCurrentScope(D->getName());
John McCallbd309292010-07-06 01:34:17 +0000520
521 // Otherwise, we need to give this label a target depth and remove
522 // it from the branch-fixups list.
523 } else {
John McCallad5d61e2010-07-23 21:56:41 +0000524 assert(!Dest.getScopeDepth().isValid() && "already emitted label!");
Nadav Rotem1da30942013-03-23 06:43:35 +0000525 Dest.setScopeDepth(EHStack.stable_begin());
John McCallad5d61e2010-07-23 21:56:41 +0000526 ResolveBranchFixups(Dest.getBlock());
John McCallbd309292010-07-06 01:34:17 +0000527 }
528
John McCallad5d61e2010-07-23 21:56:41 +0000529 EmitBlock(Dest.getBlock());
Hsiangkai Wang35751492019-01-24 05:34:29 +0000530
531 // Emit debug info for labels.
532 if (CGDebugInfo *DI = getDebugInfo()) {
533 if (CGM.getCodeGenOpts().getDebugInfo() >=
534 codegenoptions::LimitedDebugInfo) {
535 DI->setLocation(D->getLocation());
536 DI->EmitLabel(D, Builder);
537 }
538 }
539
Justin Bogner66242d62015-04-23 23:06:47 +0000540 incrementProfileCounter(D->getStmt());
Chris Lattner7e800972008-07-26 20:23:23 +0000541}
542
Nadav Rotem1da30942013-03-23 06:43:35 +0000543/// Change the cleanup scope of the labels in this lexical scope to
544/// match the scope of the enclosing context.
545void CodeGenFunction::LexicalScope::rescopeLabels() {
546 assert(!Labels.empty());
547 EHScopeStack::stable_iterator innermostScope
548 = CGF.EHStack.getInnermostNormalCleanup();
549
550 // Change the scope depth of all the labels.
551 for (SmallVectorImpl<const LabelDecl*>::const_iterator
552 i = Labels.begin(), e = Labels.end(); i != e; ++i) {
553 assert(CGF.LabelMap.count(*i));
554 JumpDest &dest = CGF.LabelMap.find(*i)->second;
555 assert(dest.getScopeDepth().isValid());
556 assert(innermostScope.encloses(dest.getScopeDepth()));
557 dest.setScopeDepth(innermostScope);
558 }
559
560 // Reparent the labels if the new scope also has cleanups.
561 if (innermostScope != EHScopeStack::stable_end() && ParentScope) {
562 ParentScope->Labels.append(Labels.begin(), Labels.end());
563 }
564}
565
Chris Lattner7e800972008-07-26 20:23:23 +0000566
567void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000568 EmitLabel(S.getDecl());
Chris Lattnere47e4402007-06-01 18:02:12 +0000569 EmitStmt(S.getSubStmt());
570}
571
Richard Smithc202b282012-04-14 00:33:13 +0000572void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) {
Karl-Johan Karlsson33e205a2017-09-06 08:47:18 +0000573 EmitStmt(S.getSubStmt(), S.getAttrs());
Richard Smithc202b282012-04-14 00:33:13 +0000574}
575
Chris Lattnere47e4402007-06-01 18:02:12 +0000576void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000577 // If this code is reachable then emit a stop point (if generating
578 // debug info). We have to do this ourselves because we are on the
579 // "simple" statement path.
580 if (HaveInsertPoint())
581 EmitStopPoint(&S);
Mike Stump1d91dd92009-02-07 12:52:26 +0000582
John McCallbd309292010-07-06 01:34:17 +0000583 EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel()));
Chris Lattnere47e4402007-06-01 18:02:12 +0000584}
585
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000586
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000587void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
Chris Lattnerc8e630e2011-02-17 07:39:24 +0000588 if (const LabelDecl *Target = S.getConstantTarget()) {
John McCall9de91602010-10-28 08:53:48 +0000589 EmitBranchThroughCleanup(getJumpDestForLabel(Target));
590 return;
591 }
592
Chris Lattner353fc1e42009-11-06 18:10:47 +0000593 // Ensure that we have an i8* for our PHI node.
Chris Lattner6c4d2552009-10-28 23:59:40 +0000594 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
John McCallad7c5c12011-02-08 08:22:06 +0000595 Int8PtrTy, "addr");
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000596 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000597
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000598 // Get the basic block for the indirect goto.
599 llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock();
Chad Rosierbebf1462012-06-20 17:43:05 +0000600
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000601 // The first instruction in the block has to be the PHI for the switch dest,
602 // add an entry for this branch.
603 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
Chad Rosierbebf1462012-06-20 17:43:05 +0000604
Chris Lattner2bb5cb42009-10-13 06:55:33 +0000605 EmitBranch(IndGotoBB);
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000606}
607
Chris Lattneraaaa1992008-11-11 07:24:28 +0000608void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
Chris Lattnere47e4402007-06-01 18:02:12 +0000609 // C99 6.8.4.1: The first substatement is executed if the expression compares
610 // unequal to 0. The condition must be a scalar type.
Adrian Prantl328f88a2014-05-28 19:10:59 +0000611 LexicalScope ConditionScope(*this, S.getCond()->getSourceRange());
Adrian Prantl0ffce6e2013-06-08 00:16:55 +0000612
Richard Smitha547eb22016-07-14 00:11:03 +0000613 if (S.getInit())
614 EmitStmt(S.getInit());
615
Douglas Gregor633caca2009-11-23 23:44:04 +0000616 if (S.getConditionVariable())
Zhihao Yuana8e2bb32018-03-17 21:01:27 +0000617 EmitDecl(*S.getConditionVariable());
Mike Stump11289f42009-09-09 15:08:12 +0000618
Chris Lattnerb7a9e162008-11-12 07:46:33 +0000619 // If the condition constant folds and can be elided, try to avoid emitting
620 // the condition and the dead arm of the if/else.
Chris Lattner41c6ab52011-02-27 23:02:32 +0000621 bool CondConstant;
Richard Smithb130fe72016-06-23 19:16:49 +0000622 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant,
623 S.isConstexpr())) {
Chris Lattneraaaa1992008-11-11 07:24:28 +0000624 // Figure out which block (then or else) is executed.
Chris Lattner41c6ab52011-02-27 23:02:32 +0000625 const Stmt *Executed = S.getThen();
626 const Stmt *Skipped = S.getElse();
627 if (!CondConstant) // Condition false?
Chris Lattneraaaa1992008-11-11 07:24:28 +0000628 std::swap(Executed, Skipped);
Mike Stump11289f42009-09-09 15:08:12 +0000629
Chris Lattneraaaa1992008-11-11 07:24:28 +0000630 // If the skipped block has no labels in it, just emit the executed block.
631 // This avoids emitting dead code and simplifies the CFG substantially.
Richard Smithb130fe72016-06-23 19:16:49 +0000632 if (S.isConstexpr() || !ContainsLabel(Skipped)) {
Justin Bogneref512b92014-01-06 22:27:43 +0000633 if (CondConstant)
Justin Bogner66242d62015-04-23 23:06:47 +0000634 incrementProfileCounter(&S);
Douglas Gregor965f4502009-11-24 16:43:22 +0000635 if (Executed) {
John McCallbd309292010-07-06 01:34:17 +0000636 RunCleanupsScope ExecutedScope(*this);
Chris Lattneraaaa1992008-11-11 07:24:28 +0000637 EmitStmt(Executed);
Douglas Gregor965f4502009-11-24 16:43:22 +0000638 }
Chris Lattneraaaa1992008-11-11 07:24:28 +0000639 return;
640 }
641 }
Chris Lattnerb7a9e162008-11-12 07:46:33 +0000642
643 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit
644 // the conditional branch.
Daniel Dunbarf75c8232008-11-13 00:47:57 +0000645 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then");
646 llvm::BasicBlock *ContBlock = createBasicBlock("if.end");
647 llvm::BasicBlock *ElseBlock = ContBlock;
Chris Lattnere47e4402007-06-01 18:02:12 +0000648 if (S.getElse())
Daniel Dunbarf75c8232008-11-13 00:47:57 +0000649 ElseBlock = createBasicBlock("if.else");
Justin Bogneref512b92014-01-06 22:27:43 +0000650
Justin Bogner66242d62015-04-23 23:06:47 +0000651 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock,
652 getProfileCount(S.getThen()));
Mike Stump11289f42009-09-09 15:08:12 +0000653
Chris Lattnere47e4402007-06-01 18:02:12 +0000654 // Emit the 'then' code.
Justin Bogneref512b92014-01-06 22:27:43 +0000655 EmitBlock(ThenBlock);
Justin Bogner66242d62015-04-23 23:06:47 +0000656 incrementProfileCounter(&S);
Douglas Gregor965f4502009-11-24 16:43:22 +0000657 {
John McCallbd309292010-07-06 01:34:17 +0000658 RunCleanupsScope ThenScope(*this);
Douglas Gregor965f4502009-11-24 16:43:22 +0000659 EmitStmt(S.getThen());
660 }
Wolfgang Pieb24e03342016-07-21 23:28:18 +0000661 EmitBranch(ContBlock);
Mike Stump11289f42009-09-09 15:08:12 +0000662
Chris Lattnere47e4402007-06-01 18:02:12 +0000663 // Emit the 'else' code if present.
664 if (const Stmt *Else = S.getElse()) {
David Blaikie1b5adb82014-07-10 20:42:59 +0000665 {
Adrian Prantl39428e72015-02-03 18:40:42 +0000666 // There is no need to emit line number for an unconditional branch.
Adrian Prantl95b24e92015-02-03 20:00:54 +0000667 auto NL = ApplyDebugLocation::CreateEmpty(*this);
David Blaikie1b5adb82014-07-10 20:42:59 +0000668 EmitBlock(ElseBlock);
669 }
Douglas Gregor965f4502009-11-24 16:43:22 +0000670 {
John McCallbd309292010-07-06 01:34:17 +0000671 RunCleanupsScope ElseScope(*this);
Douglas Gregor965f4502009-11-24 16:43:22 +0000672 EmitStmt(Else);
673 }
David Blaikie1b5adb82014-07-10 20:42:59 +0000674 {
Adrian Prantl39428e72015-02-03 18:40:42 +0000675 // There is no need to emit line number for an unconditional branch.
Adrian Prantl95b24e92015-02-03 20:00:54 +0000676 auto NL = ApplyDebugLocation::CreateEmpty(*this);
David Blaikie1b5adb82014-07-10 20:42:59 +0000677 EmitBranch(ContBlock);
678 }
Chris Lattnere47e4402007-06-01 18:02:12 +0000679 }
Mike Stump11289f42009-09-09 15:08:12 +0000680
Chris Lattnere47e4402007-06-01 18:02:12 +0000681 // Emit the continuation block for code after the if.
Daniel Dunbardf21c6e2008-11-13 01:54:24 +0000682 EmitBlock(ContBlock, true);
Chris Lattnere47e4402007-06-01 18:02:12 +0000683}
684
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000685void CodeGenFunction::EmitWhileStmt(const WhileStmt &S,
Craig Topper3cb91b22014-08-27 06:28:16 +0000686 ArrayRef<const Attr *> WhileAttrs) {
John McCallbd309292010-07-06 01:34:17 +0000687 // Emit the header for the loop, which will also become
688 // the continue target.
689 JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond");
John McCallad5d61e2010-07-23 21:56:41 +0000690 EmitBlock(LoopHeader.getBlock());
Mike Stumpdc0d6be2009-02-07 18:08:12 +0000691
Amara Emerson652795d2016-11-10 14:44:30 +0000692 const SourceRange &R = S.getSourceRange();
Hal Finkelc07e19b2016-05-25 21:53:24 +0000693 LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), WhileAttrs,
Amara Emerson652795d2016-11-10 14:44:30 +0000694 SourceLocToDebugLoc(R.getBegin()),
695 SourceLocToDebugLoc(R.getEnd()));
Alexander Musman515ad8c2014-05-22 08:54:05 +0000696
John McCallbd309292010-07-06 01:34:17 +0000697 // Create an exit block for when the condition fails, which will
698 // also become the break target.
699 JumpDest LoopExit = getJumpDestInCurrentScope("while.end");
Mike Stumpdc0d6be2009-02-07 18:08:12 +0000700
701 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000702 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
Mike Stump11289f42009-09-09 15:08:12 +0000703
Douglas Gregor680f8612009-11-24 21:15:44 +0000704 // C++ [stmt.while]p2:
705 // When the condition of a while statement is a declaration, the
706 // scope of the variable that is declared extends from its point
707 // of declaration (3.3.2) to the end of the while statement.
708 // [...]
709 // The object created in a condition is destroyed and created
710 // with each iteration of the loop.
John McCallbd309292010-07-06 01:34:17 +0000711 RunCleanupsScope ConditionScope(*this);
Douglas Gregor680f8612009-11-24 21:15:44 +0000712
John McCallbd309292010-07-06 01:34:17 +0000713 if (S.getConditionVariable())
Zhihao Yuana8e2bb32018-03-17 21:01:27 +0000714 EmitDecl(*S.getConditionVariable());
Chad Rosierbebf1462012-06-20 17:43:05 +0000715
Mike Stump1f8be1b2009-02-07 17:18:33 +0000716 // Evaluate the conditional in the while header. C99 6.8.5.1: The
717 // evaluation of the controlling expression takes place before each
718 // execution of the loop body.
Chris Lattner8394d792007-06-05 20:53:16 +0000719 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Chad Rosierbebf1462012-06-20 17:43:05 +0000720
Devang Patel152f18f2007-10-09 20:51:27 +0000721 // while(1) is common, avoid extra exit blocks. Be sure
Chris Lattner8394d792007-06-05 20:53:16 +0000722 // to correctly handle break/continue though.
Devang Patel152f18f2007-10-09 20:51:27 +0000723 bool EmitBoolCondBranch = true;
Mike Stump11289f42009-09-09 15:08:12 +0000724 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
Devang Patel152f18f2007-10-09 20:51:27 +0000725 if (C->isOne())
726 EmitBoolCondBranch = false;
Mike Stump11289f42009-09-09 15:08:12 +0000727
Chris Lattner946aa312007-06-05 03:59:43 +0000728 // As long as the condition is true, go to the loop body.
John McCallbd309292010-07-06 01:34:17 +0000729 llvm::BasicBlock *LoopBody = createBasicBlock("while.body");
730 if (EmitBoolCondBranch) {
John McCallad5d61e2010-07-23 21:56:41 +0000731 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
John McCallbd309292010-07-06 01:34:17 +0000732 if (ConditionScope.requiresCleanups())
733 ExitBlock = createBasicBlock("while.exit");
Tyler Nowicki54c020d2015-07-27 20:10:20 +0000734 Builder.CreateCondBr(
Justin Bogner66242d62015-04-23 23:06:47 +0000735 BoolCondVal, LoopBody, ExitBlock,
Justin Bogner65512642015-05-02 05:00:55 +0000736 createProfileWeightsForLoop(S.getCond(), getProfileCount(S.getBody())));
John McCallbd309292010-07-06 01:34:17 +0000737
John McCallad5d61e2010-07-23 21:56:41 +0000738 if (ExitBlock != LoopExit.getBlock()) {
John McCallbd309292010-07-06 01:34:17 +0000739 EmitBlock(ExitBlock);
740 EmitBranchThroughCleanup(LoopExit);
741 }
742 }
Chad Rosierbebf1462012-06-20 17:43:05 +0000743
John McCallbd309292010-07-06 01:34:17 +0000744 // Emit the loop body. We have to emit this in a cleanup scope
745 // because it might be a singleton DeclStmt.
Douglas Gregor680f8612009-11-24 21:15:44 +0000746 {
John McCallbd309292010-07-06 01:34:17 +0000747 RunCleanupsScope BodyScope(*this);
Douglas Gregor680f8612009-11-24 21:15:44 +0000748 EmitBlock(LoopBody);
Justin Bogner66242d62015-04-23 23:06:47 +0000749 incrementProfileCounter(&S);
Douglas Gregor680f8612009-11-24 21:15:44 +0000750 EmitStmt(S.getBody());
751 }
Chris Lattnere73e4322007-07-16 21:28:45 +0000752
Mike Stump11289f42009-09-09 15:08:12 +0000753 BreakContinueStack.pop_back();
754
John McCallbd309292010-07-06 01:34:17 +0000755 // Immediately force cleanup.
756 ConditionScope.ForceCleanup();
Douglas Gregor680f8612009-11-24 21:15:44 +0000757
David Blaikie0c8e3f22014-08-15 21:11:25 +0000758 EmitStopPoint(&S);
John McCallbd309292010-07-06 01:34:17 +0000759 // Branch to the loop header again.
John McCallad5d61e2010-07-23 21:56:41 +0000760 EmitBranch(LoopHeader.getBlock());
Mike Stump11289f42009-09-09 15:08:12 +0000761
Alexander Musman515ad8c2014-05-22 08:54:05 +0000762 LoopStack.pop();
763
Chris Lattner946aa312007-06-05 03:59:43 +0000764 // Emit the exit block.
John McCallad5d61e2010-07-23 21:56:41 +0000765 EmitBlock(LoopExit.getBlock(), true);
Douglas Gregor680f8612009-11-24 21:15:44 +0000766
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000767 // The LoopHeader typically is just a branch if we skipped emitting
768 // a branch, try to erase it.
John McCallbd309292010-07-06 01:34:17 +0000769 if (!EmitBoolCondBranch)
John McCallad5d61e2010-07-23 21:56:41 +0000770 SimplifyForwardingBlocks(LoopHeader.getBlock());
Chris Lattner946aa312007-06-05 03:59:43 +0000771}
772
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000773void CodeGenFunction::EmitDoStmt(const DoStmt &S,
Craig Topper3cb91b22014-08-27 06:28:16 +0000774 ArrayRef<const Attr *> DoAttrs) {
John McCallbd309292010-07-06 01:34:17 +0000775 JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
776 JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
Mike Stump11289f42009-09-09 15:08:12 +0000777
Justin Bogner66242d62015-04-23 23:06:47 +0000778 uint64_t ParentCount = getCurrentProfileCount();
Justin Bogneref512b92014-01-06 22:27:43 +0000779
Chris Lattnere73e4322007-07-16 21:28:45 +0000780 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000781 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
Mike Stump11289f42009-09-09 15:08:12 +0000782
John McCallbd309292010-07-06 01:34:17 +0000783 // Emit the body of the loop.
784 llvm::BasicBlock *LoopBody = createBasicBlock("do.body");
Alexander Musman515ad8c2014-05-22 08:54:05 +0000785
Justin Bogner66242d62015-04-23 23:06:47 +0000786 EmitBlockWithFallThrough(LoopBody, &S);
John McCallbd309292010-07-06 01:34:17 +0000787 {
788 RunCleanupsScope BodyScope(*this);
789 EmitStmt(S.getBody());
790 }
Mike Stump11289f42009-09-09 15:08:12 +0000791
John McCallad5d61e2010-07-23 21:56:41 +0000792 EmitBlock(LoopCond.getBlock());
Mike Stump11289f42009-09-09 15:08:12 +0000793
Bjorn Pettersson404f4142018-07-10 19:55:02 +0000794 const SourceRange &R = S.getSourceRange();
795 LoopStack.push(LoopBody, CGM.getContext(), DoAttrs,
796 SourceLocToDebugLoc(R.getBegin()),
797 SourceLocToDebugLoc(R.getEnd()));
798
Chris Lattner8394d792007-06-05 20:53:16 +0000799 // C99 6.8.5.2: "The evaluation of the controlling expression takes place
800 // after each execution of the loop body."
Mike Stump11289f42009-09-09 15:08:12 +0000801
Chris Lattner8394d792007-06-05 20:53:16 +0000802 // Evaluate the conditional in the while header.
803 // C99 6.8.5p2/p4: The first substatement is executed if the expression
804 // compares unequal to 0. The condition must be a scalar type.
805 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Devang Patelc1380402007-10-09 20:33:39 +0000806
Serge Pavlov09f99242014-01-23 15:05:00 +0000807 BreakContinueStack.pop_back();
808
Devang Patelc1380402007-10-09 20:33:39 +0000809 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure
810 // to correctly handle break/continue though.
811 bool EmitBoolCondBranch = true;
Mike Stump11289f42009-09-09 15:08:12 +0000812 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
Devang Patelc1380402007-10-09 20:33:39 +0000813 if (C->isZero())
814 EmitBoolCondBranch = false;
815
Chris Lattner8394d792007-06-05 20:53:16 +0000816 // As long as the condition is true, iterate the loop.
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000817 if (EmitBoolCondBranch) {
Justin Bogner66242d62015-04-23 23:06:47 +0000818 uint64_t BackedgeCount = getProfileCount(S.getBody()) - ParentCount;
Tyler Nowicki54c020d2015-07-27 20:10:20 +0000819 Builder.CreateCondBr(
Justin Bogner65512642015-05-02 05:00:55 +0000820 BoolCondVal, LoopBody, LoopExit.getBlock(),
821 createProfileWeightsForLoop(S.getCond(), BackedgeCount));
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000822 }
Mike Stump11289f42009-09-09 15:08:12 +0000823
Alexander Musman515ad8c2014-05-22 08:54:05 +0000824 LoopStack.pop();
825
Chris Lattner8394d792007-06-05 20:53:16 +0000826 // Emit the exit block.
John McCallad5d61e2010-07-23 21:56:41 +0000827 EmitBlock(LoopExit.getBlock());
Devang Patelc1380402007-10-09 20:33:39 +0000828
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000829 // The DoCond block typically is just a branch if we skipped
830 // emitting a branch, try to erase it.
831 if (!EmitBoolCondBranch)
John McCallad5d61e2010-07-23 21:56:41 +0000832 SimplifyForwardingBlocks(LoopCond.getBlock());
Chris Lattner8394d792007-06-05 20:53:16 +0000833}
834
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000835void CodeGenFunction::EmitForStmt(const ForStmt &S,
Craig Topper3cb91b22014-08-27 06:28:16 +0000836 ArrayRef<const Attr *> ForAttrs) {
John McCallbd309292010-07-06 01:34:17 +0000837 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
838
David Blaikie93be0b22014-08-22 21:37:04 +0000839 LexicalScope ForScope(*this, S.getSourceRange());
Devang Patel356e3e02010-08-25 00:28:56 +0000840
Chris Lattner8394d792007-06-05 20:53:16 +0000841 // Evaluate the first part before the loop.
842 if (S.getInit())
843 EmitStmt(S.getInit());
844
845 // Start the loop with a block that tests the condition.
John McCallbd309292010-07-06 01:34:17 +0000846 // If there's an increment, the continue scope will be overwritten
847 // later.
848 JumpDest Continue = getJumpDestInCurrentScope("for.cond");
John McCallad5d61e2010-07-23 21:56:41 +0000849 llvm::BasicBlock *CondBlock = Continue.getBlock();
Chris Lattner8394d792007-06-05 20:53:16 +0000850 EmitBlock(CondBlock);
851
Amara Emerson652795d2016-11-10 14:44:30 +0000852 const SourceRange &R = S.getSourceRange();
853 LoopStack.push(CondBlock, CGM.getContext(), ForAttrs,
854 SourceLocToDebugLoc(R.getBegin()),
855 SourceLocToDebugLoc(R.getEnd()));
Alexander Musman515ad8c2014-05-22 08:54:05 +0000856
Serge Pavlov09f99242014-01-23 15:05:00 +0000857 // If the for loop doesn't have an increment we can just use the
858 // condition as the continue block. Otherwise we'll need to create
859 // a block for it (in the current scope, i.e. in the scope of the
860 // condition), and that we will become our continue block.
861 if (S.getInc())
862 Continue = getJumpDestInCurrentScope("for.inc");
863
864 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000865 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
Serge Pavlov09f99242014-01-23 15:05:00 +0000866
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000867 // Create a cleanup scope for the condition variable cleanups.
David Blaikie93be0b22014-08-22 21:37:04 +0000868 LexicalScope ConditionScope(*this, S.getSourceRange());
Chad Rosierbebf1462012-06-20 17:43:05 +0000869
Chris Lattner8394d792007-06-05 20:53:16 +0000870 if (S.getCond()) {
Douglas Gregor7bab5ff2009-11-25 00:27:52 +0000871 // If the for statement has a condition scope, emit the local variable
872 // declaration.
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000873 if (S.getConditionVariable()) {
Zhihao Yuana8e2bb32018-03-17 21:01:27 +0000874 EmitDecl(*S.getConditionVariable());
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000875 }
John McCallbd309292010-07-06 01:34:17 +0000876
Justin Bogner085e28e2013-11-04 16:13:18 +0000877 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
John McCallbd309292010-07-06 01:34:17 +0000878 // If there are any cleanups between here and the loop-exit scope,
879 // create a block to stage a loop exit along.
880 if (ForScope.requiresCleanups())
881 ExitBlock = createBasicBlock("for.cond.cleanup");
Chad Rosierbebf1462012-06-20 17:43:05 +0000882
Chris Lattner8394d792007-06-05 20:53:16 +0000883 // As long as the condition is true, iterate the loop.
Daniel Dunbara612e792008-11-13 01:38:36 +0000884 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
Mike Stump11289f42009-09-09 15:08:12 +0000885
Chris Lattnercd439292008-11-12 08:04:58 +0000886 // C99 6.8.5p2/p4: The first substatement is executed if the expression
887 // compares unequal to 0. The condition must be a scalar type.
Justin Bogner7fa2eb92013-11-22 10:20:43 +0000888 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Tyler Nowicki54c020d2015-07-27 20:10:20 +0000889 Builder.CreateCondBr(
Justin Bogner66242d62015-04-23 23:06:47 +0000890 BoolCondVal, ForBody, ExitBlock,
Justin Bogner65512642015-05-02 05:00:55 +0000891 createProfileWeightsForLoop(S.getCond(), getProfileCount(S.getBody())));
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000892
John McCallad5d61e2010-07-23 21:56:41 +0000893 if (ExitBlock != LoopExit.getBlock()) {
John McCallbd309292010-07-06 01:34:17 +0000894 EmitBlock(ExitBlock);
895 EmitBranchThroughCleanup(LoopExit);
896 }
Mike Stump11289f42009-09-09 15:08:12 +0000897
898 EmitBlock(ForBody);
Chris Lattner8394d792007-06-05 20:53:16 +0000899 } else {
900 // Treat it as a non-zero constant. Don't even create a new block for the
901 // body, just fall into it.
902 }
Justin Bogner66242d62015-04-23 23:06:47 +0000903 incrementProfileCounter(&S);
Chris Lattner8394d792007-06-05 20:53:16 +0000904
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000905 {
906 // Create a separate cleanup scope for the body, in case it is not
907 // a compound statement.
John McCallbd309292010-07-06 01:34:17 +0000908 RunCleanupsScope BodyScope(*this);
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000909 EmitStmt(S.getBody());
910 }
Chris Lattnere73e4322007-07-16 21:28:45 +0000911
Chris Lattner8394d792007-06-05 20:53:16 +0000912 // If there is an increment, emit it next.
Daniel Dunbara2d35702008-09-28 00:19:22 +0000913 if (S.getInc()) {
John McCallad5d61e2010-07-23 21:56:41 +0000914 EmitBlock(Continue.getBlock());
Chris Lattner6278e6a2007-08-11 00:04:45 +0000915 EmitStmt(S.getInc());
Daniel Dunbara2d35702008-09-28 00:19:22 +0000916 }
Mike Stump11289f42009-09-09 15:08:12 +0000917
Douglas Gregor3fe900e2010-05-21 18:36:48 +0000918 BreakContinueStack.pop_back();
Douglas Gregor3d9e90a2009-11-25 01:51:31 +0000919
John McCallbd309292010-07-06 01:34:17 +0000920 ConditionScope.ForceCleanup();
David Blaikie7bc2da12014-08-22 22:25:37 +0000921
922 EmitStopPoint(&S);
John McCallbd309292010-07-06 01:34:17 +0000923 EmitBranch(CondBlock);
924
925 ForScope.ForceCleanup();
926
Alexander Musman515ad8c2014-05-22 08:54:05 +0000927 LoopStack.pop();
928
Chris Lattnere73e4322007-07-16 21:28:45 +0000929 // Emit the fall-through block.
John McCallad5d61e2010-07-23 21:56:41 +0000930 EmitBlock(LoopExit.getBlock(), true);
Chris Lattner8394d792007-06-05 20:53:16 +0000931}
Chris Lattner946aa312007-06-05 03:59:43 +0000932
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000933void
934CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S,
Craig Topper3cb91b22014-08-27 06:28:16 +0000935 ArrayRef<const Attr *> ForAttrs) {
Richard Smith02e85f32011-04-14 22:09:26 +0000936 JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
937
David Blaikieac0a5c42014-08-22 21:54:29 +0000938 LexicalScope ForScope(*this, S.getSourceRange());
Richard Smith02e85f32011-04-14 22:09:26 +0000939
940 // Evaluate the first pieces before the loop.
Richard Smith8baa5002018-09-28 18:44:09 +0000941 if (S.getInit())
942 EmitStmt(S.getInit());
Richard Smith02e85f32011-04-14 22:09:26 +0000943 EmitStmt(S.getRangeStmt());
Richard Smith01694c32016-03-20 10:33:40 +0000944 EmitStmt(S.getBeginStmt());
945 EmitStmt(S.getEndStmt());
Richard Smith02e85f32011-04-14 22:09:26 +0000946
947 // Start the loop with a block that tests the condition.
948 // If there's an increment, the continue scope will be overwritten
949 // later.
950 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
951 EmitBlock(CondBlock);
952
Amara Emerson652795d2016-11-10 14:44:30 +0000953 const SourceRange &R = S.getSourceRange();
954 LoopStack.push(CondBlock, CGM.getContext(), ForAttrs,
955 SourceLocToDebugLoc(R.getBegin()),
956 SourceLocToDebugLoc(R.getEnd()));
Alexander Musman515ad8c2014-05-22 08:54:05 +0000957
Richard Smith02e85f32011-04-14 22:09:26 +0000958 // If there are any cleanups between here and the loop-exit scope,
959 // create a block to stage a loop exit along.
960 llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
961 if (ForScope.requiresCleanups())
962 ExitBlock = createBasicBlock("for.cond.cleanup");
Chad Rosierbebf1462012-06-20 17:43:05 +0000963
Richard Smith02e85f32011-04-14 22:09:26 +0000964 // The loop body, consisting of the specified body and the loop variable.
965 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
966
967 // The body is executed if the expression, contextually converted
968 // to bool, is true.
Justin Bogner7fa2eb92013-11-22 10:20:43 +0000969 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Tyler Nowicki54c020d2015-07-27 20:10:20 +0000970 Builder.CreateCondBr(
Justin Bogner66242d62015-04-23 23:06:47 +0000971 BoolCondVal, ForBody, ExitBlock,
Justin Bogner65512642015-05-02 05:00:55 +0000972 createProfileWeightsForLoop(S.getCond(), getProfileCount(S.getBody())));
Aaron Ballmanb06b15a2014-06-06 12:40:24 +0000973
Richard Smith02e85f32011-04-14 22:09:26 +0000974 if (ExitBlock != LoopExit.getBlock()) {
975 EmitBlock(ExitBlock);
976 EmitBranchThroughCleanup(LoopExit);
977 }
978
979 EmitBlock(ForBody);
Justin Bogner66242d62015-04-23 23:06:47 +0000980 incrementProfileCounter(&S);
Richard Smith02e85f32011-04-14 22:09:26 +0000981
982 // Create a block for the increment. In case of a 'continue', we jump there.
983 JumpDest Continue = getJumpDestInCurrentScope("for.inc");
984
985 // Store the blocks to use for break and continue.
Bob Wilsonbf854f02014-02-17 19:21:09 +0000986 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
Richard Smith02e85f32011-04-14 22:09:26 +0000987
988 {
989 // Create a separate cleanup scope for the loop variable and body.
David Blaikieac0a5c42014-08-22 21:54:29 +0000990 LexicalScope BodyScope(*this, S.getSourceRange());
Richard Smith02e85f32011-04-14 22:09:26 +0000991 EmitStmt(S.getLoopVarStmt());
992 EmitStmt(S.getBody());
993 }
994
David Blaikie15c49562014-08-15 20:50:45 +0000995 EmitStopPoint(&S);
Richard Smith02e85f32011-04-14 22:09:26 +0000996 // If there is an increment, emit it next.
997 EmitBlock(Continue.getBlock());
998 EmitStmt(S.getInc());
999
1000 BreakContinueStack.pop_back();
1001
1002 EmitBranch(CondBlock);
1003
1004 ForScope.ForceCleanup();
1005
Alexander Musman515ad8c2014-05-22 08:54:05 +00001006 LoopStack.pop();
1007
Richard Smith02e85f32011-04-14 22:09:26 +00001008 // Emit the fall-through block.
1009 EmitBlock(LoopExit.getBlock(), true);
1010}
1011
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00001012void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) {
1013 if (RV.isScalar()) {
1014 Builder.CreateStore(RV.getScalarVal(), ReturnValue);
1015 } else if (RV.isAggregate()) {
Ivan A. Kosarev1860b522018-01-25 14:21:55 +00001016 LValue Dest = MakeAddrLValue(ReturnValue, Ty);
1017 LValue Src = MakeAddrLValue(RV.getAggregateAddress(), Ty);
Richard Smithe78fac52018-04-05 20:52:58 +00001018 EmitAggregateCopy(Dest, Src, Ty, overlapForReturnValue());
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00001019 } else {
John McCall7f416cc2015-09-08 08:05:57 +00001020 EmitStoreOfComplex(RV.getComplexVal(), MakeAddrLValue(ReturnValue, Ty),
John McCall47fb9502013-03-07 21:37:08 +00001021 /*init*/ true);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00001022 }
Anders Carlsson1ac62822009-02-09 20:31:03 +00001023 EmitBranchThroughCleanup(ReturnBlock);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00001024}
1025
Chris Lattner3f3dbee2007-06-02 03:19:07 +00001026/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand
1027/// if the function returns void, or may be missing one if the function returns
1028/// non-void. Fun stuff :).
1029void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
Vedant Kumarc34d3432017-06-23 21:32:38 +00001030 if (requiresReturnValueCheck()) {
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001031 llvm::Constant *SLoc = EmitCheckSourceLocation(S.getBeginLoc());
Vedant Kumarc34d3432017-06-23 21:32:38 +00001032 auto *SLocPtr =
1033 new llvm::GlobalVariable(CGM.getModule(), SLoc->getType(), false,
1034 llvm::GlobalVariable::PrivateLinkage, SLoc);
1035 SLocPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1036 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(SLocPtr);
1037 assert(ReturnLocation.isValid() && "No valid return location");
1038 Builder.CreateStore(Builder.CreateBitCast(SLocPtr, Int8PtrTy),
1039 ReturnLocation);
1040 }
1041
Reid Klecknerebaf28d2015-04-14 20:59:00 +00001042 // Returning from an outlined SEH helper is UB, and we already warn on it.
1043 if (IsOutlinedSEHHelper) {
1044 Builder.CreateUnreachable();
1045 Builder.ClearInsertionPoint();
1046 }
1047
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +00001048 // Emit the result value, even if unused, to evaluate the side effects.
Chris Lattner3f3dbee2007-06-02 03:19:07 +00001049 const Expr *RV = S.getRetValue();
Mike Stump11289f42009-09-09 15:08:12 +00001050
John McCallb0433ee2012-09-25 06:56:03 +00001051 // Treat block literals in a return expression as if they appeared
1052 // in their own scope. This permits a small, easily-implemented
1053 // exception to our over-conservative rules about not jumping to
1054 // statements following block literals with non-trivial cleanups.
1055 RunCleanupsScope cleanupScope(*this);
Bill Wendling7c44da22018-10-31 03:48:47 +00001056 if (const FullExpr *fe = dyn_cast_or_null<FullExpr>(RV)) {
1057 enterFullExpression(fe);
1058 RV = fe->getSubExpr();
John McCallb0433ee2012-09-25 06:56:03 +00001059 }
1060
Daniel Dunbar54bb1932008-09-09 21:00:17 +00001061 // FIXME: Clean this up by using an LValue for ReturnTemp,
1062 // EmitStoreThroughLValue, and EmitAnyExpr.
Richard Smith454b4af2014-01-11 01:24:05 +00001063 if (getLangOpts().ElideConstructors &&
1064 S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) {
Douglas Gregor290c93e2010-05-15 06:46:45 +00001065 // Apply the named return value optimization for this return statement,
1066 // which means doing nothing: the appropriate result has already been
1067 // constructed into the NRVO variable.
Chad Rosierbebf1462012-06-20 17:43:05 +00001068
Douglas Gregor9154b5d2010-05-17 15:52:46 +00001069 // If there is an NRVO flag for this variable, set it to 1 into indicate
1070 // that the cleanup code should not destroy the variable.
John McCallad7c5c12011-02-08 08:22:06 +00001071 if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()])
John McCall7f416cc2015-09-08 08:05:57 +00001072 Builder.CreateFlagStore(Builder.getTrue(), NRVOFlag);
1073 } else if (!ReturnValue.isValid() || (RV && RV->getType()->isVoidType())) {
Daniel Dunbar54bb1932008-09-09 21:00:17 +00001074 // Make sure not to return anything, but evaluate the expression
1075 // for side effects.
1076 if (RV)
Eli Friedmanc7460b12008-05-22 01:22:33 +00001077 EmitAnyExpr(RV);
Craig Topper8a13c412014-05-21 05:09:00 +00001078 } else if (!RV) {
Daniel Dunbar54bb1932008-09-09 21:00:17 +00001079 // Do nothing (return value is left uninitialized)
Eli Friedmanb909bf42009-05-27 04:56:12 +00001080 } else if (FnRetTy->isReferenceType()) {
1081 // If this function returns a reference, take the address of the expression
1082 // rather than the value.
Richard Smitha1c9d4d2013-06-12 23:38:09 +00001083 RValue Result = EmitReferenceBindingToExpr(RV);
Douglas Gregor02dde142010-03-24 23:14:04 +00001084 Builder.CreateStore(Result.getScalarVal(), ReturnValue);
Chris Lattner3f3dbee2007-06-02 03:19:07 +00001085 } else {
John McCall47fb9502013-03-07 21:37:08 +00001086 switch (getEvaluationKind(RV->getType())) {
1087 case TEK_Scalar:
1088 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue);
1089 break;
1090 case TEK_Complex:
John McCall7f416cc2015-09-08 08:05:57 +00001091 EmitComplexExprIntoLValue(RV, MakeAddrLValue(ReturnValue, RV->getType()),
John McCall47fb9502013-03-07 21:37:08 +00001092 /*isInit*/ true);
1093 break;
John McCall7f416cc2015-09-08 08:05:57 +00001094 case TEK_Aggregate:
Richard Smithe78fac52018-04-05 20:52:58 +00001095 EmitAggExpr(RV, AggValueSlot::forAddr(
1096 ReturnValue, Qualifiers(),
1097 AggValueSlot::IsDestructed,
1098 AggValueSlot::DoesNotNeedGCBarriers,
1099 AggValueSlot::IsNotAliased,
1100 overlapForReturnValue()));
John McCall47fb9502013-03-07 21:37:08 +00001101 break;
1102 }
Chris Lattner3f3dbee2007-06-02 03:19:07 +00001103 }
Eli Friedmanc7460b12008-05-22 01:22:33 +00001104
Adrian Prantl8f1fb6f2013-05-07 22:41:09 +00001105 ++NumReturnExprs;
Craig Topper8a13c412014-05-21 05:09:00 +00001106 if (!RV || RV->isEvaluatable(getContext()))
Adrian Prantl8f1fb6f2013-05-07 22:41:09 +00001107 ++NumSimpleReturnExprs;
Adrian Prantl3be10542013-05-02 17:30:20 +00001108
John McCallb0433ee2012-09-25 06:56:03 +00001109 cleanupScope.ForceCleanup();
Anders Carlsson1ac62822009-02-09 20:31:03 +00001110 EmitBranchThroughCleanup(ReturnBlock);
Chris Lattner3f3dbee2007-06-02 03:19:07 +00001111}
1112
Chris Lattner1ad38f82007-06-09 01:20:56 +00001113void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
Devang Patel1b291b22011-06-04 00:38:02 +00001114 // As long as debug info is modeled with instructions, we have to ensure we
1115 // have a place to insert here and write the stop point here.
Eric Christopher3910ec92012-04-10 05:04:07 +00001116 if (HaveInsertPoint())
Devang Patel1b291b22011-06-04 00:38:02 +00001117 EmitStopPoint(&S);
1118
Aaron Ballman535bbcc2014-03-14 17:01:24 +00001119 for (const auto *I : S.decls())
1120 EmitDecl(*I);
Chris Lattnerbd4de5df2007-07-12 15:43:07 +00001121}
Chris Lattnere73e4322007-07-16 21:28:45 +00001122
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001123void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) {
Chris Lattnere73e4322007-07-16 21:28:45 +00001124 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
1125
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001126 // If this code is reachable then emit a stop point (if generating
1127 // debug info). We have to do this ourselves because we are on the
1128 // "simple" statement path.
1129 if (HaveInsertPoint())
1130 EmitStopPoint(&S);
Mike Stump284d1772009-02-08 09:22:19 +00001131
Bob Wilsonbf854f02014-02-17 19:21:09 +00001132 EmitBranchThroughCleanup(BreakContinueStack.back().BreakBlock);
Chris Lattnere73e4322007-07-16 21:28:45 +00001133}
1134
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001135void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) {
Chris Lattnere73e4322007-07-16 21:28:45 +00001136 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
1137
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001138 // If this code is reachable then emit a stop point (if generating
1139 // debug info). We have to do this ourselves because we are on the
1140 // "simple" statement path.
1141 if (HaveInsertPoint())
1142 EmitStopPoint(&S);
Mike Stump284d1772009-02-08 09:22:19 +00001143
Bob Wilsonbf854f02014-02-17 19:21:09 +00001144 EmitBranchThroughCleanup(BreakContinueStack.back().ContinueBlock);
Chris Lattnere73e4322007-07-16 21:28:45 +00001145}
Devang Patelda5d6bb2007-10-04 23:45:31 +00001146
Devang Patel11663122007-10-08 20:57:48 +00001147/// EmitCaseStmtRange - If case statement range is not too big then
1148/// add multiple cases to switch instruction, one for each value within
1149/// the range. If range is too big then emit "if" condition check.
1150void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
Daniel Dunbar2e0f1cd2008-07-24 01:18:41 +00001151 assert(S.getRHS() && "Expected RHS value in CaseStmt");
Devang Patel11663122007-10-08 20:57:48 +00001152
Richard Smithcaf33902011-10-10 18:28:20 +00001153 llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext());
1154 llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext());
Daniel Dunbar2e0f1cd2008-07-24 01:18:41 +00001155
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001156 // Emit the code for this case. We do this first to make sure it is
1157 // properly chained from our predecessor before generating the
1158 // switch machinery to enter this block.
Bob Wilsonbf854f02014-02-17 19:21:09 +00001159 llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb");
Justin Bogner66242d62015-04-23 23:06:47 +00001160 EmitBlockWithFallThrough(CaseDest, &S);
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001161 EmitStmt(S.getSubStmt());
1162
Daniel Dunbar2e0f1cd2008-07-24 01:18:41 +00001163 // If range is empty, do nothing.
1164 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
1165 return;
Devang Patel11663122007-10-08 20:57:48 +00001166
1167 llvm::APInt Range = RHS - LHS;
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001168 // FIXME: parameters such as this should not be hardcoded.
Devang Patel11663122007-10-08 20:57:48 +00001169 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
1170 // Range is small enough to add multiple switch instruction cases.
Justin Bogner66242d62015-04-23 23:06:47 +00001171 uint64_t Total = getProfileCount(&S);
Justin Bogneref512b92014-01-06 22:27:43 +00001172 unsigned NCases = Range.getZExtValue() + 1;
Justin Bogner3fac6492014-01-13 21:24:25 +00001173 // We only have one region counter for the entire set of cases here, so we
1174 // need to divide the weights evenly between the generated cases, ensuring
Bob Wilsona7b16e02014-02-17 19:21:03 +00001175 // that the total weight is preserved. E.g., a weight of 5 over three cases
Justin Bogner3fac6492014-01-13 21:24:25 +00001176 // will be distributed as weights of 2, 2, and 1.
Justin Bogneref512b92014-01-06 22:27:43 +00001177 uint64_t Weight = Total / NCases, Rem = Total % NCases;
1178 for (unsigned I = 0; I != NCases; ++I) {
1179 if (SwitchWeights)
1180 SwitchWeights->push_back(Weight + (Rem ? 1 : 0));
1181 if (Rem)
1182 Rem--;
Chris Lattner46f16142011-04-19 20:53:45 +00001183 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest);
Craig Topper61e14d82017-04-19 21:02:45 +00001184 ++LHS;
Devang Patel64a9ca72007-10-05 20:54:07 +00001185 }
Devang Patel11663122007-10-08 20:57:48 +00001186 return;
Mike Stump11289f42009-09-09 15:08:12 +00001187 }
1188
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001189 // The range is too big. Emit "if" condition into a new block,
1190 // making sure to save and restore the current insertion point.
1191 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
Devang Patel64a9ca72007-10-05 20:54:07 +00001192
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001193 // Push this test onto the chain of range checks (which terminates
1194 // in the default basic block). The switch's default will be changed
1195 // to the top of this chain after switch emission is complete.
1196 llvm::BasicBlock *FalseDest = CaseRangeBlock;
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001197 CaseRangeBlock = createBasicBlock("sw.caserange");
Devang Patel11663122007-10-08 20:57:48 +00001198
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001199 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
1200 Builder.SetInsertPoint(CaseRangeBlock);
Devang Patel11663122007-10-08 20:57:48 +00001201
1202 // Emit range check.
Mike Stump11289f42009-09-09 15:08:12 +00001203 llvm::Value *Diff =
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001204 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
Mike Stump11289f42009-09-09 15:08:12 +00001205 llvm::Value *Cond =
Chris Lattner46f16142011-04-19 20:53:45 +00001206 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
Justin Bogneref512b92014-01-06 22:27:43 +00001207
Craig Topper8a13c412014-05-21 05:09:00 +00001208 llvm::MDNode *Weights = nullptr;
Justin Bogneref512b92014-01-06 22:27:43 +00001209 if (SwitchWeights) {
Justin Bogner66242d62015-04-23 23:06:47 +00001210 uint64_t ThisCount = getProfileCount(&S);
Justin Bogneref512b92014-01-06 22:27:43 +00001211 uint64_t DefaultCount = (*SwitchWeights)[0];
Justin Bogner65512642015-05-02 05:00:55 +00001212 Weights = createProfileWeights(ThisCount, DefaultCount);
Justin Bogneref512b92014-01-06 22:27:43 +00001213
1214 // Since we're chaining the switch default through each large case range, we
1215 // need to update the weight for the default, ie, the first case, to include
1216 // this case.
1217 (*SwitchWeights)[0] += ThisCount;
1218 }
1219 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
Devang Patel11663122007-10-08 20:57:48 +00001220
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001221 // Restore the appropriate insertion point.
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00001222 if (RestoreBB)
1223 Builder.SetInsertPoint(RestoreBB);
1224 else
1225 Builder.ClearInsertionPoint();
Devang Patel11663122007-10-08 20:57:48 +00001226}
1227
1228void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) {
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001229 // If there is no enclosing switch instance that we're aware of, then this
1230 // case statement and its block can be elided. This situation only happens
1231 // when we've constant-folded the switch, are emitting the constant case,
Justin Bogner0f066062013-11-22 10:20:40 +00001232 // and part of the constant case includes another case statement. For
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001233 // instance: switch (4) { case 4: do { case 5: } while (1); }
Fariborz Jahanian07b5f4c2012-01-17 23:55:19 +00001234 if (!SwitchInsn) {
1235 EmitStmt(S.getSubStmt());
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001236 return;
Fariborz Jahanian07b5f4c2012-01-17 23:55:19 +00001237 }
Fariborz Jahanian9c882f92012-01-16 17:35:57 +00001238
Chris Lattnerbc204c82011-04-17 00:54:30 +00001239 // Handle case ranges.
Devang Patel11663122007-10-08 20:57:48 +00001240 if (S.getRHS()) {
1241 EmitCaseStmtRange(S);
1242 return;
1243 }
Mike Stump11289f42009-09-09 15:08:12 +00001244
Chris Lattner46f16142011-04-19 20:53:45 +00001245 llvm::ConstantInt *CaseVal =
Richard Smithcaf33902011-10-10 18:28:20 +00001246 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
Chris Lattner46f16142011-04-19 20:53:45 +00001247
Justin Bognere25ffdf2014-01-21 00:35:11 +00001248 // If the body of the case is just a 'break', try to not emit an empty block.
1249 // If we're profiling or we're not optimizing, leave the block in for better
1250 // debug and coverage analysis.
Rong Xu9837ef52016-02-04 18:39:09 +00001251 if (!CGM.getCodeGenOpts().hasProfileClangInstr() &&
Justin Bognere25ffdf2014-01-21 00:35:11 +00001252 CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1253 isa<BreakStmt>(S.getSubStmt())) {
1254 JumpDest Block = BreakContinueStack.back().BreakBlock;
1255
1256 // Only do this optimization if there are no cleanups that need emitting.
1257 if (isObviouslyBranchWithoutCleanups(Block)) {
1258 if (SwitchWeights)
Justin Bogner66242d62015-04-23 23:06:47 +00001259 SwitchWeights->push_back(getProfileCount(&S));
Justin Bognere25ffdf2014-01-21 00:35:11 +00001260 SwitchInsn->addCase(CaseVal, Block.getBlock());
1261
1262 // If there was a fallthrough into this case, make sure to redirect it to
1263 // the end of the switch as well.
1264 if (Builder.GetInsertBlock()) {
1265 Builder.CreateBr(Block.getBlock());
1266 Builder.ClearInsertionPoint();
1267 }
1268 return;
1269 }
1270 }
1271
Bob Wilsonbf854f02014-02-17 19:21:09 +00001272 llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb");
Justin Bogner66242d62015-04-23 23:06:47 +00001273 EmitBlockWithFallThrough(CaseDest, &S);
Justin Bogneref512b92014-01-06 22:27:43 +00001274 if (SwitchWeights)
Justin Bogner66242d62015-04-23 23:06:47 +00001275 SwitchWeights->push_back(getProfileCount(&S));
Chris Lattner46f16142011-04-19 20:53:45 +00001276 SwitchInsn->addCase(CaseVal, CaseDest);
Mike Stump11289f42009-09-09 15:08:12 +00001277
Chris Lattner4192bce2009-03-04 04:46:18 +00001278 // Recursively emitting the statement is acceptable, but is not wonderful for
1279 // code where we have many case statements nested together, i.e.:
1280 // case 1:
1281 // case 2:
1282 // case 3: etc.
1283 // Handling this recursively will create a new block for each case statement
1284 // that falls through to the next case which is IR intensive. It also causes
1285 // deep recursion which can run into stack depth limitations. Handle
1286 // sequential non-range case statements specially.
1287 const CaseStmt *CurCase = &S;
1288 const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt());
1289
Chris Lattner46f16142011-04-19 20:53:45 +00001290 // Otherwise, iteratively add consecutive cases to this switch stmt.
Craig Topper8a13c412014-05-21 05:09:00 +00001291 while (NextCase && NextCase->getRHS() == nullptr) {
Chris Lattner4192bce2009-03-04 04:46:18 +00001292 CurCase = NextCase;
Justin Bogneref512b92014-01-06 22:27:43 +00001293 llvm::ConstantInt *CaseVal =
Richard Smithcaf33902011-10-10 18:28:20 +00001294 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
Justin Bogneref512b92014-01-06 22:27:43 +00001295
Justin Bogneref512b92014-01-06 22:27:43 +00001296 if (SwitchWeights)
Justin Bogner66242d62015-04-23 23:06:47 +00001297 SwitchWeights->push_back(getProfileCount(NextCase));
Rong Xu9837ef52016-02-04 18:39:09 +00001298 if (CGM.getCodeGenOpts().hasProfileClangInstr()) {
Bob Wilsonbf854f02014-02-17 19:21:09 +00001299 CaseDest = createBasicBlock("sw.bb");
Justin Bogner66242d62015-04-23 23:06:47 +00001300 EmitBlockWithFallThrough(CaseDest, &S);
Bob Wilsonbf854f02014-02-17 19:21:09 +00001301 }
Justin Bogneref512b92014-01-06 22:27:43 +00001302
Chris Lattner46f16142011-04-19 20:53:45 +00001303 SwitchInsn->addCase(CaseVal, CaseDest);
Chris Lattner4192bce2009-03-04 04:46:18 +00001304 NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt());
1305 }
Mike Stump11289f42009-09-09 15:08:12 +00001306
Chris Lattner4192bce2009-03-04 04:46:18 +00001307 // Normal default recursion for non-cases.
1308 EmitStmt(CurCase->getSubStmt());
Devang Patelda5d6bb2007-10-04 23:45:31 +00001309}
1310
1311void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {
Erik Pilkington1ac8adf2016-07-21 22:31:40 +00001312 // If there is no enclosing switch instance that we're aware of, then this
1313 // default statement can be elided. This situation only happens when we've
1314 // constant-folded the switch.
1315 if (!SwitchInsn) {
1316 EmitStmt(S.getSubStmt());
1317 return;
1318 }
1319
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001320 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
Mike Stump11289f42009-09-09 15:08:12 +00001321 assert(DefaultBlock->empty() &&
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001322 "EmitDefaultStmt: Default block already defined?");
Justin Bogneref512b92014-01-06 22:27:43 +00001323
Justin Bogner66242d62015-04-23 23:06:47 +00001324 EmitBlockWithFallThrough(DefaultBlock, &S);
Justin Bogneref512b92014-01-06 22:27:43 +00001325
Devang Patelda5d6bb2007-10-04 23:45:31 +00001326 EmitStmt(S.getSubStmt());
1327}
1328
Chris Lattner0725a8b2011-02-28 00:22:07 +00001329/// CollectStatementsForCase - Given the body of a 'switch' statement and a
1330/// constant value that is being switched on, see if we can dead code eliminate
1331/// the body of the switch to a simple series of statements to emit. Basically,
1332/// on a switch (5) we want to find these statements:
1333/// case 5:
1334/// printf(...); <--
1335/// ++i; <--
1336/// break;
1337///
1338/// and add them to the ResultStmts vector. If it is unsafe to do this
1339/// transformation (for example, one of the elided statements contains a label
1340/// that might be jumped to), return CSFC_Failure. If we handled it and 'S'
1341/// should include statements after it (e.g. the printf() line is a substmt of
1342/// the case) then return CSFC_FallThrough. If we handled it and found a break
1343/// statement, then return CSFC_Success.
1344///
1345/// If Case is non-null, then we are looking for the specified case, checking
1346/// that nothing we jump over contains labels. If Case is null, then we found
1347/// the case and are looking for the break.
1348///
1349/// If the recursive walk actually finds our Case, then we set FoundCase to
1350/// true.
1351///
1352enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success };
1353static CSFC_Result CollectStatementsForCase(const Stmt *S,
1354 const SwitchCase *Case,
1355 bool &FoundCase,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001356 SmallVectorImpl<const Stmt*> &ResultStmts) {
Chris Lattner07095422011-02-28 01:02:29 +00001357 // If this is a null statement, just succeed.
Craig Topper8a13c412014-05-21 05:09:00 +00001358 if (!S)
Chris Lattner07095422011-02-28 01:02:29 +00001359 return Case ? CSFC_Success : CSFC_FallThrough;
Chad Rosierbebf1462012-06-20 17:43:05 +00001360
Chris Lattner0725a8b2011-02-28 00:22:07 +00001361 // If this is the switchcase (case 4: or default) that we're looking for, then
1362 // we're in business. Just add the substatement.
1363 if (const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1364 if (S == Case) {
1365 FoundCase = true;
Craig Topper8a13c412014-05-21 05:09:00 +00001366 return CollectStatementsForCase(SC->getSubStmt(), nullptr, FoundCase,
Chris Lattner0725a8b2011-02-28 00:22:07 +00001367 ResultStmts);
1368 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001369
Chris Lattner0725a8b2011-02-28 00:22:07 +00001370 // Otherwise, this is some other case or default statement, just ignore it.
1371 return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase,
1372 ResultStmts);
1373 }
Chris Lattner07095422011-02-28 01:02:29 +00001374
1375 // If we are in the live part of the code and we found our break statement,
1376 // return a success!
Craig Topper8a13c412014-05-21 05:09:00 +00001377 if (!Case && isa<BreakStmt>(S))
Chris Lattner07095422011-02-28 01:02:29 +00001378 return CSFC_Success;
Chad Rosierbebf1462012-06-20 17:43:05 +00001379
Chris Lattner07095422011-02-28 01:02:29 +00001380 // If this is a switch statement, then it might contain the SwitchCase, the
1381 // break, or neither.
1382 if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1383 // Handle this as two cases: we might be looking for the SwitchCase (if so
1384 // the skipped statements must be skippable) or we might already have it.
1385 CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end();
Richard Smithd8e3ac32016-09-16 23:30:39 +00001386 bool StartedInLiveCode = FoundCase;
1387 unsigned StartSize = ResultStmts.size();
1388
1389 // If we've not found the case yet, scan through looking for it.
Chris Lattner07095422011-02-28 01:02:29 +00001390 if (Case) {
Chris Lattner35d3ac52011-02-28 07:22:44 +00001391 // Keep track of whether we see a skipped declaration. The code could be
1392 // using the declaration even if it is skipped, so we can't optimize out
1393 // the decl if the kept statements might refer to it.
1394 bool HadSkippedDecl = false;
Chad Rosierbebf1462012-06-20 17:43:05 +00001395
Chris Lattner07095422011-02-28 01:02:29 +00001396 // If we're looking for the case, just see if we can skip each of the
1397 // substatements.
1398 for (; Case && I != E; ++I) {
Richard Smithd8e3ac32016-09-16 23:30:39 +00001399 HadSkippedDecl |= CodeGenFunction::mightAddDeclToScope(*I);
Chad Rosierbebf1462012-06-20 17:43:05 +00001400
Chris Lattner07095422011-02-28 01:02:29 +00001401 switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) {
1402 case CSFC_Failure: return CSFC_Failure;
1403 case CSFC_Success:
1404 // A successful result means that either 1) that the statement doesn't
1405 // have the case and is skippable, or 2) does contain the case value
Chris Lattner62208c32011-02-28 07:16:14 +00001406 // and also contains the break to exit the switch. In the later case,
1407 // we just verify the rest of the statements are elidable.
1408 if (FoundCase) {
Chris Lattner35d3ac52011-02-28 07:22:44 +00001409 // If we found the case and skipped declarations, we can't do the
1410 // optimization.
1411 if (HadSkippedDecl)
1412 return CSFC_Failure;
Chad Rosierbebf1462012-06-20 17:43:05 +00001413
Chris Lattner62208c32011-02-28 07:16:14 +00001414 for (++I; I != E; ++I)
1415 if (CodeGenFunction::ContainsLabel(*I, true))
1416 return CSFC_Failure;
1417 return CSFC_Success;
1418 }
Chris Lattner07095422011-02-28 01:02:29 +00001419 break;
1420 case CSFC_FallThrough:
1421 // If we have a fallthrough condition, then we must have found the
1422 // case started to include statements. Consider the rest of the
1423 // statements in the compound statement as candidates for inclusion.
1424 assert(FoundCase && "Didn't find case but returned fallthrough?");
1425 // We recursively found Case, so we're not looking for it anymore.
Craig Topper8a13c412014-05-21 05:09:00 +00001426 Case = nullptr;
Chad Rosierbebf1462012-06-20 17:43:05 +00001427
Chris Lattner35d3ac52011-02-28 07:22:44 +00001428 // If we found the case and skipped declarations, we can't do the
1429 // optimization.
1430 if (HadSkippedDecl)
1431 return CSFC_Failure;
Chris Lattner07095422011-02-28 01:02:29 +00001432 break;
1433 }
1434 }
Richard Smithd8e3ac32016-09-16 23:30:39 +00001435
1436 if (!FoundCase)
1437 return CSFC_Success;
1438
1439 assert(!HadSkippedDecl && "fallthrough after skipping decl");
Chris Lattner07095422011-02-28 01:02:29 +00001440 }
1441
1442 // If we have statements in our range, then we know that the statements are
1443 // live and need to be added to the set of statements we're tracking.
Richard Smithd8e3ac32016-09-16 23:30:39 +00001444 bool AnyDecls = false;
Chris Lattner07095422011-02-28 01:02:29 +00001445 for (; I != E; ++I) {
Richard Smithd8e3ac32016-09-16 23:30:39 +00001446 AnyDecls |= CodeGenFunction::mightAddDeclToScope(*I);
1447
Craig Topper8a13c412014-05-21 05:09:00 +00001448 switch (CollectStatementsForCase(*I, nullptr, FoundCase, ResultStmts)) {
Chris Lattner07095422011-02-28 01:02:29 +00001449 case CSFC_Failure: return CSFC_Failure;
1450 case CSFC_FallThrough:
1451 // A fallthrough result means that the statement was simple and just
1452 // included in ResultStmt, keep adding them afterwards.
1453 break;
1454 case CSFC_Success:
1455 // A successful result means that we found the break statement and
1456 // stopped statement inclusion. We just ensure that any leftover stmts
1457 // are skippable and return success ourselves.
1458 for (++I; I != E; ++I)
1459 if (CodeGenFunction::ContainsLabel(*I, true))
1460 return CSFC_Failure;
1461 return CSFC_Success;
Chad Rosierbebf1462012-06-20 17:43:05 +00001462 }
Chris Lattner07095422011-02-28 01:02:29 +00001463 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001464
Richard Smithd8e3ac32016-09-16 23:30:39 +00001465 // If we're about to fall out of a scope without hitting a 'break;', we
1466 // can't perform the optimization if there were any decls in that scope
1467 // (we'd lose their end-of-lifetime).
1468 if (AnyDecls) {
1469 // If the entire compound statement was live, there's one more thing we
1470 // can try before giving up: emit the whole thing as a single statement.
1471 // We can do that unless the statement contains a 'break;'.
1472 // FIXME: Such a break must be at the end of a construct within this one.
1473 // We could emit this by just ignoring the BreakStmts entirely.
1474 if (StartedInLiveCode && !CodeGenFunction::containsBreak(S)) {
1475 ResultStmts.resize(StartSize);
1476 ResultStmts.push_back(S);
1477 } else {
1478 return CSFC_Failure;
1479 }
1480 }
1481
1482 return CSFC_FallThrough;
Chris Lattner07095422011-02-28 01:02:29 +00001483 }
1484
Chris Lattner0725a8b2011-02-28 00:22:07 +00001485 // Okay, this is some other statement that we don't handle explicitly, like a
1486 // for statement or increment etc. If we are skipping over this statement,
1487 // just verify it doesn't have labels, which would make it invalid to elide.
1488 if (Case) {
Chris Lattner35d3ac52011-02-28 07:22:44 +00001489 if (CodeGenFunction::ContainsLabel(S, true))
Chris Lattner0725a8b2011-02-28 00:22:07 +00001490 return CSFC_Failure;
1491 return CSFC_Success;
1492 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001493
Chris Lattner0725a8b2011-02-28 00:22:07 +00001494 // Otherwise, we want to include this statement. Everything is cool with that
1495 // so long as it doesn't contain a break out of the switch we're in.
1496 if (CodeGenFunction::containsBreak(S)) return CSFC_Failure;
Chad Rosierbebf1462012-06-20 17:43:05 +00001497
Chris Lattner0725a8b2011-02-28 00:22:07 +00001498 // Otherwise, everything is great. Include the statement and tell the caller
1499 // that we fall through and include the next statement as well.
1500 ResultStmts.push_back(S);
1501 return CSFC_FallThrough;
1502}
1503
1504/// FindCaseStatementsForValue - Find the case statement being jumped to and
1505/// then invoke CollectStatementsForCase to find the list of statements to emit
1506/// for a switch on constant. See the comment above CollectStatementsForCase
1507/// for more details.
1508static bool FindCaseStatementsForValue(const SwitchStmt &S,
Richard Trieuc320c742012-07-23 20:21:35 +00001509 const llvm::APSInt &ConstantCondValue,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001510 SmallVectorImpl<const Stmt*> &ResultStmts,
Justin Bogneref512b92014-01-06 22:27:43 +00001511 ASTContext &C,
1512 const SwitchCase *&ResultCase) {
Chris Lattner0725a8b2011-02-28 00:22:07 +00001513 // First step, find the switch case that is being branched to. We can do this
1514 // efficiently by scanning the SwitchCase list.
1515 const SwitchCase *Case = S.getSwitchCaseList();
Craig Topper8a13c412014-05-21 05:09:00 +00001516 const DefaultStmt *DefaultCase = nullptr;
Chad Rosierbebf1462012-06-20 17:43:05 +00001517
Chris Lattner0725a8b2011-02-28 00:22:07 +00001518 for (; Case; Case = Case->getNextSwitchCase()) {
1519 // It's either a default or case. Just remember the default statement in
1520 // case we're not jumping to any numbered cases.
1521 if (const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1522 DefaultCase = DS;
1523 continue;
1524 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001525
Chris Lattner0725a8b2011-02-28 00:22:07 +00001526 // Check to see if this case is the one we're looking for.
1527 const CaseStmt *CS = cast<CaseStmt>(Case);
1528 // Don't handle case ranges yet.
1529 if (CS->getRHS()) return false;
Chad Rosierbebf1462012-06-20 17:43:05 +00001530
Chris Lattner0725a8b2011-02-28 00:22:07 +00001531 // If we found our case, remember it as 'case'.
Richard Smithcaf33902011-10-10 18:28:20 +00001532 if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue)
Chris Lattner0725a8b2011-02-28 00:22:07 +00001533 break;
1534 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001535
Chris Lattner0725a8b2011-02-28 00:22:07 +00001536 // If we didn't find a matching case, we use a default if it exists, or we
1537 // elide the whole switch body!
Craig Topper8a13c412014-05-21 05:09:00 +00001538 if (!Case) {
Chris Lattner0725a8b2011-02-28 00:22:07 +00001539 // It is safe to elide the body of the switch if it doesn't contain labels
1540 // etc. If it is safe, return successfully with an empty ResultStmts list.
Craig Topper8a13c412014-05-21 05:09:00 +00001541 if (!DefaultCase)
Chris Lattner0725a8b2011-02-28 00:22:07 +00001542 return !CodeGenFunction::ContainsLabel(&S);
1543 Case = DefaultCase;
1544 }
1545
1546 // Ok, we know which case is being jumped to, try to collect all the
1547 // statements that follow it. This can fail for a variety of reasons. Also,
1548 // check to see that the recursive walk actually found our case statement.
1549 // Insane cases like this can fail to find it in the recursive walk since we
1550 // don't handle every stmt kind:
1551 // switch (4) {
1552 // while (1) {
1553 // case 4: ...
1554 bool FoundCase = false;
Justin Bogneref512b92014-01-06 22:27:43 +00001555 ResultCase = Case;
Chris Lattner0725a8b2011-02-28 00:22:07 +00001556 return CollectStatementsForCase(S.getBody(), Case, FoundCase,
1557 ResultStmts) != CSFC_Failure &&
1558 FoundCase;
1559}
1560
Devang Patelda5d6bb2007-10-04 23:45:31 +00001561void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) {
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001562 // Handle nested switch statements.
1563 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
Justin Bogneref512b92014-01-06 22:27:43 +00001564 SmallVector<uint64_t, 16> *SavedSwitchWeights = SwitchWeights;
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001565 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1566
Chris Lattner0725a8b2011-02-28 00:22:07 +00001567 // See if we can constant fold the condition of the switch and therefore only
1568 // emit the live case statement (if any) of the switch.
Richard Trieuc320c742012-07-23 20:21:35 +00001569 llvm::APSInt ConstantCondValue;
Chris Lattner0725a8b2011-02-28 00:22:07 +00001570 if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001571 SmallVector<const Stmt*, 4> CaseStmts;
Craig Topper8a13c412014-05-21 05:09:00 +00001572 const SwitchCase *Case = nullptr;
Chris Lattner0725a8b2011-02-28 00:22:07 +00001573 if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts,
Justin Bogneref512b92014-01-06 22:27:43 +00001574 getContext(), Case)) {
Justin Bogner66242d62015-04-23 23:06:47 +00001575 if (Case)
1576 incrementProfileCounter(Case);
Chris Lattner0725a8b2011-02-28 00:22:07 +00001577 RunCleanupsScope ExecutedScope(*this);
1578
Richard Smitha547eb22016-07-14 00:11:03 +00001579 if (S.getInit())
1580 EmitStmt(S.getInit());
1581
Chandler Carruth7d866822014-05-03 00:14:49 +00001582 // Emit the condition variable if needed inside the entire cleanup scope
1583 // used by this special case for constant folded switches.
1584 if (S.getConditionVariable())
Zhihao Yuana8e2bb32018-03-17 21:01:27 +00001585 EmitDecl(*S.getConditionVariable());
Chandler Carruth7d866822014-05-03 00:14:49 +00001586
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001587 // At this point, we are no longer "within" a switch instance, so
1588 // we can temporarily enforce this to ensure that any embedded case
1589 // statements are not emitted.
Craig Topper8a13c412014-05-21 05:09:00 +00001590 SwitchInsn = nullptr;
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001591
Chris Lattner0725a8b2011-02-28 00:22:07 +00001592 // Okay, we can dead code eliminate everything except this case. Emit the
1593 // specified series of statements and we're good.
1594 for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1595 EmitStmt(CaseStmts[i]);
Justin Bogner66242d62015-04-23 23:06:47 +00001596 incrementProfileCounter(&S);
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001597
Eric Christophercdbde692012-04-10 05:04:04 +00001598 // Now we want to restore the saved switch instance so that nested
1599 // switches continue to function properly
Fariborz Jahanian9ce39e22012-01-17 23:39:50 +00001600 SwitchInsn = SavedSwitchInsn;
1601
Chris Lattner0725a8b2011-02-28 00:22:07 +00001602 return;
1603 }
1604 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001605
Chandler Carruth7d866822014-05-03 00:14:49 +00001606 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog");
1607
1608 RunCleanupsScope ConditionScope(*this);
Richard Smitha547eb22016-07-14 00:11:03 +00001609
1610 if (S.getInit())
1611 EmitStmt(S.getInit());
1612
Chandler Carruth7d866822014-05-03 00:14:49 +00001613 if (S.getConditionVariable())
Zhihao Yuana8e2bb32018-03-17 21:01:27 +00001614 EmitDecl(*S.getConditionVariable());
Devang Patelda5d6bb2007-10-04 23:45:31 +00001615 llvm::Value *CondV = EmitScalarExpr(S.getCond());
1616
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001617 // Create basic block to hold stuff that comes after switch
1618 // statement. We also need to create a default block now so that
1619 // explicit case ranges tests can have a place to jump to on
1620 // failure.
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001621 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default");
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001622 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
Justin Bogneref512b92014-01-06 22:27:43 +00001623 if (PGO.haveRegionCounts()) {
1624 // Walk the SwitchCase list to find how many there are.
1625 uint64_t DefaultCount = 0;
1626 unsigned NumCases = 0;
1627 for (const SwitchCase *Case = S.getSwitchCaseList();
1628 Case;
1629 Case = Case->getNextSwitchCase()) {
1630 if (isa<DefaultStmt>(Case))
Justin Bogner66242d62015-04-23 23:06:47 +00001631 DefaultCount = getProfileCount(Case);
Justin Bogneref512b92014-01-06 22:27:43 +00001632 NumCases += 1;
1633 }
1634 SwitchWeights = new SmallVector<uint64_t, 16>();
1635 SwitchWeights->reserve(NumCases);
1636 // The default needs to be first. We store the edge count, so we already
1637 // know the right weight.
1638 SwitchWeights->push_back(DefaultCount);
1639 }
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001640 CaseRangeBlock = DefaultBlock;
Devang Patelda5d6bb2007-10-04 23:45:31 +00001641
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001642 // Clear the insertion point to indicate we are in unreachable code.
1643 Builder.ClearInsertionPoint();
Eli Friedman6a7087e2008-05-12 16:08:04 +00001644
Alp Tokerd4733632013-12-05 04:47:09 +00001645 // All break statements jump to NextBlock. If BreakContinueStack is non-empty
Bob Wilsonbf854f02014-02-17 19:21:09 +00001646 // then reuse last ContinueBlock.
John McCallbd309292010-07-06 01:34:17 +00001647 JumpDest OuterContinue;
Bob Wilsonbf854f02014-02-17 19:21:09 +00001648 if (!BreakContinueStack.empty())
1649 OuterContinue = BreakContinueStack.back().ContinueBlock;
Anders Carlsson33747b62009-02-10 05:52:02 +00001650
Bob Wilsonbf854f02014-02-17 19:21:09 +00001651 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
Devang Patelda5d6bb2007-10-04 23:45:31 +00001652
1653 // Emit switch body.
1654 EmitStmt(S.getBody());
Mike Stump11289f42009-09-09 15:08:12 +00001655
Anders Carlsson33747b62009-02-10 05:52:02 +00001656 BreakContinueStack.pop_back();
Devang Patelda5d6bb2007-10-04 23:45:31 +00001657
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001658 // Update the default block in case explicit case range tests have
1659 // been chained on top.
Stepan Dyatkovskiy5fecf5442012-02-01 07:50:21 +00001660 SwitchInsn->setDefaultDest(CaseRangeBlock);
Mike Stump11289f42009-09-09 15:08:12 +00001661
John McCallbd309292010-07-06 01:34:17 +00001662 // If a default was never emitted:
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001663 if (!DefaultBlock->getParent()) {
John McCallbd309292010-07-06 01:34:17 +00001664 // If we have cleanups, emit the default block so that there's a
1665 // place to jump through the cleanups from.
1666 if (ConditionScope.requiresCleanups()) {
1667 EmitBlock(DefaultBlock);
1668
1669 // Otherwise, just forward the default block to the switch end.
1670 } else {
John McCallad5d61e2010-07-23 21:56:41 +00001671 DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock());
John McCallbd309292010-07-06 01:34:17 +00001672 delete DefaultBlock;
1673 }
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001674 }
Devang Patelda5d6bb2007-10-04 23:45:31 +00001675
John McCallad5d61e2010-07-23 21:56:41 +00001676 ConditionScope.ForceCleanup();
1677
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001678 // Emit continuation.
John McCallad5d61e2010-07-23 21:56:41 +00001679 EmitBlock(SwitchExit.getBlock(), true);
Justin Bogner66242d62015-04-23 23:06:47 +00001680 incrementProfileCounter(&S);
Daniel Dunbar0e5845c2008-07-25 01:11:38 +00001681
Sanjay Pateldaf34e92015-09-09 22:39:06 +00001682 // If the switch has a condition wrapped by __builtin_unpredictable,
1683 // create metadata that specifies that the switch is unpredictable.
1684 // Don't bother if not optimizing because that metadata would not be used.
Sanjay Patel341890a2016-04-19 17:13:14 +00001685 auto *Call = dyn_cast<CallExpr>(S.getCond());
1686 if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) {
1687 auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1688 if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1689 llvm::MDBuilder MDHelper(getLLVMContext());
1690 SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable,
1691 MDHelper.createUnpredictable());
Sanjay Pateldaf34e92015-09-09 22:39:06 +00001692 }
1693 }
1694
Justin Bogneref512b92014-01-06 22:27:43 +00001695 if (SwitchWeights) {
1696 assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&
1697 "switch weights do not match switch cases");
1698 // If there's only one jump destination there's no sense weighting it.
1699 if (SwitchWeights->size() > 1)
1700 SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,
Justin Bogner65512642015-05-02 05:00:55 +00001701 createProfileWeights(*SwitchWeights));
Justin Bogneref512b92014-01-06 22:27:43 +00001702 delete SwitchWeights;
1703 }
Devang Patelda5d6bb2007-10-04 23:45:31 +00001704 SwitchInsn = SavedSwitchInsn;
Justin Bogneref512b92014-01-06 22:27:43 +00001705 SwitchWeights = SavedSwitchWeights;
Devang Patel11663122007-10-08 20:57:48 +00001706 CaseRangeBlock = SavedCRBlock;
Devang Patelda5d6bb2007-10-04 23:45:31 +00001707}
Anders Carlsson952a9952008-02-05 16:35:33 +00001708
Chris Lattnerc16d4762009-04-26 17:57:12 +00001709static std::string
Daniel Dunbar1b444192009-11-13 05:51:54 +00001710SimplifyConstraint(const char *Constraint, const TargetInfo &Target,
Craig Topper8a13c412014-05-21 05:09:00 +00001711 SmallVectorImpl<TargetInfo::ConstraintInfo> *OutCons=nullptr) {
Anders Carlsson952a9952008-02-05 16:35:33 +00001712 std::string Result;
Mike Stump11289f42009-09-09 15:08:12 +00001713
Anders Carlsson952a9952008-02-05 16:35:33 +00001714 while (*Constraint) {
1715 switch (*Constraint) {
1716 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001717 Result += Target.convertConstraint(Constraint);
Anders Carlsson952a9952008-02-05 16:35:33 +00001718 break;
1719 // Ignore these
1720 case '*':
1721 case '?':
1722 case '!':
John Thompsona5c7d702010-08-10 19:20:14 +00001723 case '=': // Will see this and the following in mult-alt constraints.
1724 case '+':
1725 break;
Ulrich Weigand7bcc7ec2012-10-29 12:20:54 +00001726 case '#': // Ignore the rest of the constraint alternative.
1727 while (Constraint[1] && Constraint[1] != ',')
Eric Christopher872018b2013-07-10 20:14:36 +00001728 Constraint++;
Ulrich Weigand7bcc7ec2012-10-29 12:20:54 +00001729 break;
David Majnemer14d4e7b2015-01-11 09:09:01 +00001730 case '&':
David Majnemerf1fdf4a2015-01-11 09:13:56 +00001731 case '%':
1732 Result += *Constraint;
1733 while (Constraint[1] && Constraint[1] == *Constraint)
David Majnemer14d4e7b2015-01-11 09:09:01 +00001734 Constraint++;
1735 break;
John Thompson12240612010-09-18 01:15:13 +00001736 case ',':
1737 Result += "|";
Anders Carlsson952a9952008-02-05 16:35:33 +00001738 break;
1739 case 'g':
1740 Result += "imr";
1741 break;
Anders Carlssona92271d2009-01-18 02:06:20 +00001742 case '[': {
Chris Lattnerc16d4762009-04-26 17:57:12 +00001743 assert(OutCons &&
Anders Carlssona92271d2009-01-18 02:06:20 +00001744 "Must pass output names to constraints with a symbolic name");
1745 unsigned Index;
Craig Topper55765ca2015-10-21 02:34:10 +00001746 bool result = Target.resolveSymbolicName(Constraint, *OutCons, Index);
Chris Lattner63c41a22011-01-05 18:41:53 +00001747 assert(result && "Could not resolve symbolic name"); (void)result;
Anders Carlssona92271d2009-01-18 02:06:20 +00001748 Result += llvm::utostr(Index);
1749 break;
1750 }
Anders Carlsson952a9952008-02-05 16:35:33 +00001751 }
Mike Stump11289f42009-09-09 15:08:12 +00001752
Anders Carlsson952a9952008-02-05 16:35:33 +00001753 Constraint++;
1754 }
Mike Stump11289f42009-09-09 15:08:12 +00001755
Anders Carlsson952a9952008-02-05 16:35:33 +00001756 return Result;
1757}
1758
Rafael Espindola5734edc2011-01-01 21:12:33 +00001759/// AddVariableConstraints - Look at AsmExpr and if it is a variable declared
1760/// as using a particular register add that as a constraint that will be used
1761/// in this asm stmt.
Rafael Espindolac56f8472010-12-30 22:59:32 +00001762static std::string
Rafael Espindola5734edc2011-01-01 21:12:33 +00001763AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
1764 const TargetInfo &Target, CodeGenModule &CGM,
Daniel Sandersaa748a82015-02-04 14:25:47 +00001765 const AsmStmt &Stmt, const bool EarlyClobber) {
Rafael Espindolac56f8472010-12-30 22:59:32 +00001766 const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);
1767 if (!AsmDeclRef)
1768 return Constraint;
1769 const ValueDecl &Value = *AsmDeclRef->getDecl();
1770 const VarDecl *Variable = dyn_cast<VarDecl>(&Value);
1771 if (!Variable)
1772 return Constraint;
Eli Friedman6f87b442012-03-15 23:12:51 +00001773 if (Variable->getStorageClass() != SC_Register)
1774 return Constraint;
Rafael Espindolac56f8472010-12-30 22:59:32 +00001775 AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>();
1776 if (!Attr)
1777 return Constraint;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001778 StringRef Register = Attr->getLabel();
Rafael Espindola478abca2011-01-01 21:47:03 +00001779 assert(Target.isValidGCCRegisterName(Register));
Eric Christophere9544252011-06-17 01:53:34 +00001780 // We're using validateOutputConstraint here because we only care if
1781 // this is a register constraint.
1782 TargetInfo::ConstraintInfo Info(Constraint, "");
1783 if (Target.validateOutputConstraint(Info) &&
1784 !Info.allowsRegister()) {
Rafael Espindolac56f8472010-12-30 22:59:32 +00001785 CGM.ErrorUnsupported(&Stmt, "__asm__");
1786 return Constraint;
1787 }
Eric Christopherb4a791f2011-06-21 00:07:10 +00001788 // Canonicalize the register here before returning it.
1789 Register = Target.getNormalizedGCCRegisterName(Register);
Daniel Sandersaa748a82015-02-04 14:25:47 +00001790 return (EarlyClobber ? "&{" : "{") + Register.str() + "}";
Rafael Espindolac56f8472010-12-30 22:59:32 +00001791}
1792
Eli Friedmaneca55af2010-07-16 00:55:21 +00001793llvm::Value*
Chad Rosier59df25b2012-08-23 20:00:18 +00001794CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info,
Eli Friedmaneca55af2010-07-16 00:55:21 +00001795 LValue InputValue, QualType InputType,
Nick Lewycky2d84e842013-10-02 02:29:49 +00001796 std::string &ConstraintStr,
1797 SourceLocation Loc) {
Anders Carlssonda5f5692009-01-11 19:32:54 +00001798 llvm::Value *Arg;
Mike Stump11289f42009-09-09 15:08:12 +00001799 if (Info.allowsRegister() || !Info.allowsMemory()) {
John McCall47fb9502013-03-07 21:37:08 +00001800 if (CodeGenFunction::hasScalarEvaluationKind(InputType)) {
Nick Lewycky2d84e842013-10-02 02:29:49 +00001801 Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal();
Anders Carlssonda5f5692009-01-11 19:32:54 +00001802 } else {
Chris Lattner2192fe52011-07-18 04:24:23 +00001803 llvm::Type *Ty = ConvertType(InputType);
Micah Villmowdd31ca12012-10-08 16:25:52 +00001804 uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty);
Anders Carlsson00057e42009-01-12 02:22:13 +00001805 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
John McCallad7c5c12011-02-08 08:22:06 +00001806 Ty = llvm::IntegerType::get(getLLVMContext(), Size);
Anders Carlsson00057e42009-01-12 02:22:13 +00001807 Ty = llvm::PointerType::getUnqual(Ty);
Mike Stump11289f42009-09-09 15:08:12 +00001808
Eli Friedmaneca55af2010-07-16 00:55:21 +00001809 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1810 Ty));
Anders Carlsson00057e42009-01-12 02:22:13 +00001811 } else {
John McCall7f416cc2015-09-08 08:05:57 +00001812 Arg = InputValue.getPointer();
Anders Carlsson00057e42009-01-12 02:22:13 +00001813 ConstraintStr += '*';
1814 }
Anders Carlssonda5f5692009-01-11 19:32:54 +00001815 }
1816 } else {
John McCall7f416cc2015-09-08 08:05:57 +00001817 Arg = InputValue.getPointer();
Anders Carlssonda5f5692009-01-11 19:32:54 +00001818 ConstraintStr += '*';
1819 }
Mike Stump11289f42009-09-09 15:08:12 +00001820
Anders Carlssonda5f5692009-01-11 19:32:54 +00001821 return Arg;
1822}
1823
Chad Rosier59df25b2012-08-23 20:00:18 +00001824llvm::Value* CodeGenFunction::EmitAsmInput(
Eli Friedmaneca55af2010-07-16 00:55:21 +00001825 const TargetInfo::ConstraintInfo &Info,
1826 const Expr *InputExpr,
1827 std::string &ConstraintStr) {
Ahmed Bougachaff75f3d2015-06-11 18:19:34 +00001828 // If this can't be a register or memory, i.e., has to be a constant
1829 // (immediate or symbolic), try to emit it as such.
1830 if (!Info.allowsRegister() && !Info.allowsMemory()) {
Bill Wendlingaa775132018-12-18 22:54:03 +00001831 if (Info.requiresImmediateConstant()) {
1832 llvm::APSInt AsmConst = InputExpr->EvaluateKnownConstInt(getContext());
1833 return llvm::ConstantInt::get(getLLVMContext(), AsmConst);
1834 }
1835
Fangrui Song407659a2018-11-30 23:41:18 +00001836 Expr::EvalResult Result;
Ahmed Bougachaf6a9f0e2015-06-13 01:16:10 +00001837 if (InputExpr->EvaluateAsInt(Result, getContext()))
Fangrui Song407659a2018-11-30 23:41:18 +00001838 return llvm::ConstantInt::get(getLLVMContext(), Result.Val.getInt());
Ahmed Bougachaff75f3d2015-06-11 18:19:34 +00001839 }
1840
Eli Friedmaneca55af2010-07-16 00:55:21 +00001841 if (Info.allowsRegister() || !Info.allowsMemory())
John McCall47fb9502013-03-07 21:37:08 +00001842 if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType()))
Eli Friedmaneca55af2010-07-16 00:55:21 +00001843 return EmitScalarExpr(InputExpr);
Michael Zuckerman229158c2015-12-15 14:04:18 +00001844 if (InputExpr->getStmtClass() == Expr::CXXThisExprClass)
1845 return EmitScalarExpr(InputExpr);
Eli Friedmaneca55af2010-07-16 00:55:21 +00001846 InputExpr = InputExpr->IgnoreParenNoopCasts(getContext());
1847 LValue Dest = EmitLValue(InputExpr);
Nick Lewycky2d84e842013-10-02 02:29:49 +00001848 return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr,
1849 InputExpr->getExprLoc());
Eli Friedmaneca55af2010-07-16 00:55:21 +00001850}
1851
Chris Lattner776a30d2010-11-17 05:58:54 +00001852/// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline
Chris Lattner11feaf52010-11-17 08:25:26 +00001853/// asm call instruction. The !srcloc MDNode contains a list of constant
1854/// integers which are the source locations of the start of each line in the
1855/// asm.
Chris Lattner776a30d2010-11-17 05:58:54 +00001856static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str,
1857 CodeGenFunction &CGF) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001858 SmallVector<llvm::Metadata *, 8> Locs;
Chris Lattner11feaf52010-11-17 08:25:26 +00001859 // Add the location of the first line to the MDNode.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001860 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001861 CGF.Int32Ty, Str->getBeginLoc().getRawEncoding())));
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001862 StringRef StrVal = Str->getString();
Chris Lattner11feaf52010-11-17 08:25:26 +00001863 if (!StrVal.empty()) {
1864 const SourceManager &SM = CGF.CGM.getContext().getSourceManager();
David Blaikiebbafb8a2012-03-11 07:00:24 +00001865 const LangOptions &LangOpts = CGF.CGM.getLangOpts();
Richard Smithefb116f2015-12-10 01:11:47 +00001866 unsigned StartToken = 0;
1867 unsigned ByteOffset = 0;
Chad Rosierbebf1462012-06-20 17:43:05 +00001868
Chris Lattner11feaf52010-11-17 08:25:26 +00001869 // Add the location of the start of each subsequent line of the asm to the
1870 // MDNode.
Richard Smithefb116f2015-12-10 01:11:47 +00001871 for (unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {
Chris Lattner11feaf52010-11-17 08:25:26 +00001872 if (StrVal[i] != '\n') continue;
Richard Smithefb116f2015-12-10 01:11:47 +00001873 SourceLocation LineLoc = Str->getLocationOfByte(
1874 i + 1, SM, LangOpts, CGF.getTarget(), &StartToken, &ByteOffset);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001875 Locs.push_back(llvm::ConstantAsMetadata::get(
1876 llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())));
Chris Lattner11feaf52010-11-17 08:25:26 +00001877 }
Chad Rosierbebf1462012-06-20 17:43:05 +00001878 }
1879
Jay Foadea324f12011-04-21 19:59:12 +00001880 return llvm::MDNode::get(CGF.getLLVMContext(), Locs);
Chris Lattner776a30d2010-11-17 05:58:54 +00001881}
1882
Chad Rosier6051bb92012-08-28 18:54:39 +00001883void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
Chad Rosier14836ba2012-08-24 17:05:45 +00001884 // Assemble the final asm string.
Chad Rosier3b0c2602012-08-27 20:23:31 +00001885 std::string AsmString = S.generateAsmString(getContext());
Mike Stump11289f42009-09-09 15:08:12 +00001886
Chris Lattner17769a32009-05-03 07:05:00 +00001887 // Get all the output and input constraints together.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001888 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1889 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
Chris Lattner17769a32009-05-03 07:05:00 +00001890
Mike Stump11289f42009-09-09 15:08:12 +00001891 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
John McCallf413f5e2013-05-03 00:10:13 +00001892 StringRef Name;
1893 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1894 Name = GAS->getOutputName(i);
1895 TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name);
John McCallc8e01702013-04-16 22:48:15 +00001896 bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid;
Justin Bogner0f066062013-11-22 10:20:40 +00001897 assert(IsValid && "Failed to parse output constraint");
Chris Lattner17769a32009-05-03 07:05:00 +00001898 OutputConstraintInfos.push_back(Info);
Mike Stump11289f42009-09-09 15:08:12 +00001899 }
1900
Chris Lattner17769a32009-05-03 07:05:00 +00001901 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
John McCallf413f5e2013-05-03 00:10:13 +00001902 StringRef Name;
1903 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1904 Name = GAS->getInputName(i);
1905 TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name);
John McCallc8e01702013-04-16 22:48:15 +00001906 bool IsValid =
Craig Topper55765ca2015-10-21 02:34:10 +00001907 getTarget().validateInputConstraint(OutputConstraintInfos, Info);
Chris Lattner576def72010-03-03 21:52:23 +00001908 assert(IsValid && "Failed to parse input constraint"); (void)IsValid;
Chris Lattner17769a32009-05-03 07:05:00 +00001909 InputConstraintInfos.push_back(Info);
1910 }
Mike Stump11289f42009-09-09 15:08:12 +00001911
Anders Carlsson952a9952008-02-05 16:35:33 +00001912 std::string Constraints;
Mike Stump11289f42009-09-09 15:08:12 +00001913
Chris Lattner10f221f2009-05-03 07:53:25 +00001914 std::vector<LValue> ResultRegDests;
1915 std::vector<QualType> ResultRegQualTys;
Jay Foad7c57be32011-07-11 09:56:20 +00001916 std::vector<llvm::Type *> ResultRegTypes;
1917 std::vector<llvm::Type *> ResultTruncRegTypes;
Chad Rosier5a032fa2012-05-01 19:53:37 +00001918 std::vector<llvm::Type *> ArgTypes;
Anders Carlsson952a9952008-02-05 16:35:33 +00001919 std::vector<llvm::Value*> Args;
Anders Carlssonb170d0c2008-02-05 20:01:53 +00001920
1921 // Keep track of inout constraints.
1922 std::string InOutConstraints;
1923 std::vector<llvm::Value*> InOutArgs;
Chris Lattnera5f58b02011-07-09 17:41:47 +00001924 std::vector<llvm::Type*> InOutArgTypes;
Anders Carlsson570c3572009-01-27 20:38:24 +00001925
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00001926 // An inline asm can be marked readonly if it meets the following conditions:
1927 // - it doesn't have any sideeffects
1928 // - it doesn't clobber memory
1929 // - it doesn't return a value by-reference
1930 // It can be marked readnone if it doesn't have any input memory constraints
1931 // in addition to meeting the conditions listed above.
1932 bool ReadOnly = true, ReadNone = true;
1933
Mike Stump11289f42009-09-09 15:08:12 +00001934 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
Chris Lattner17769a32009-05-03 07:05:00 +00001935 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
Anders Carlsson570c3572009-01-27 20:38:24 +00001936
Anders Carlsson952a9952008-02-05 16:35:33 +00001937 // Simplify the output constraint.
Chris Lattner17769a32009-05-03 07:05:00 +00001938 std::string OutputConstraint(S.getOutputConstraint(i));
John McCallc8e01702013-04-16 22:48:15 +00001939 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1,
Yaxun Liuac1263c2018-03-23 19:43:42 +00001940 getTarget(), &OutputConstraintInfos);
Mike Stump11289f42009-09-09 15:08:12 +00001941
Chris Lattnercda4d7e2009-03-13 17:38:01 +00001942 const Expr *OutExpr = S.getOutputExpr(i);
1943 OutExpr = OutExpr->IgnoreParenNoopCasts(getContext());
Mike Stump11289f42009-09-09 15:08:12 +00001944
Eric Christophere97fee62011-06-03 14:52:25 +00001945 OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr,
Daniel Sandersaa748a82015-02-04 14:25:47 +00001946 getTarget(), CGM, S,
1947 Info.earlyClobber());
Rafael Espindolac56f8472010-12-30 22:59:32 +00001948
Chris Lattnercda4d7e2009-03-13 17:38:01 +00001949 LValue Dest = EmitLValue(OutExpr);
Chris Lattner10f221f2009-05-03 07:53:25 +00001950 if (!Constraints.empty())
Anders Carlssonb4e46322009-05-01 00:16:04 +00001951 Constraints += ',';
1952
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001953 // If this is a register output, then make the inline asm return it
1954 // by-value. If this is a memory result, return the value by-reference.
John McCall47fb9502013-03-07 21:37:08 +00001955 if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) {
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001956 Constraints += "=" + OutputConstraint;
Chris Lattner10f221f2009-05-03 07:53:25 +00001957 ResultRegQualTys.push_back(OutExpr->getType());
1958 ResultRegDests.push_back(Dest);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001959 ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType()));
1960 ResultTruncRegTypes.push_back(ResultRegTypes.back());
Mike Stump11289f42009-09-09 15:08:12 +00001961
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001962 // If this output is tied to an input, and if the input is larger, then
1963 // we need to set the actual result type of the inline asm node to be the
1964 // same as the input type.
1965 if (Info.hasMatchingInput()) {
Chris Lattner99837de2009-05-03 08:38:58 +00001966 unsigned InputNo;
1967 for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) {
1968 TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo];
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001969 if (Input.hasTiedOperand() && Input.getTiedOperand() == i)
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001970 break;
Chris Lattner99837de2009-05-03 08:38:58 +00001971 }
1972 assert(InputNo != S.getNumInputs() && "Didn't find matching input!");
Mike Stump11289f42009-09-09 15:08:12 +00001973
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001974 QualType InputTy = S.getInputExpr(InputNo)->getType();
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001975 QualType OutputType = OutExpr->getType();
Mike Stump11289f42009-09-09 15:08:12 +00001976
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001977 uint64_t InputSize = getContext().getTypeSize(InputTy);
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00001978 if (getContext().getTypeSize(OutputType) < InputSize) {
1979 // Form the asm to return the value as a larger integer or fp type.
1980 ResultRegTypes.back() = ConvertType(InputTy);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00001981 }
1982 }
Tim Northover0ae93912013-06-07 00:04:50 +00001983 if (llvm::Type* AdjTy =
Peter Collingbourne8f5cf742011-02-19 23:03:58 +00001984 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
1985 ResultRegTypes.back()))
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001986 ResultRegTypes.back() = AdjTy;
Tim Northover0ae93912013-06-07 00:04:50 +00001987 else {
1988 CGM.getDiags().Report(S.getAsmLoc(),
1989 diag::err_asm_invalid_type_in_input)
1990 << OutExpr->getType() << OutputConstraint;
1991 }
Craig Topper2a873142018-08-14 20:21:05 +00001992
1993 // Update largest vector width for any vector types.
1994 if (auto *VT = dyn_cast<llvm::VectorType>(ResultRegTypes.back()))
1995 LargestVectorWidth = std::max(LargestVectorWidth,
1996 VT->getPrimitiveSizeInBits());
Anders Carlsson952a9952008-02-05 16:35:33 +00001997 } else {
John McCall7f416cc2015-09-08 08:05:57 +00001998 ArgTypes.push_back(Dest.getAddress().getType());
1999 Args.push_back(Dest.getPointer());
Anders Carlssonb170d0c2008-02-05 20:01:53 +00002000 Constraints += "=*";
Anders Carlsson952a9952008-02-05 16:35:33 +00002001 Constraints += OutputConstraint;
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00002002 ReadOnly = ReadNone = false;
Anders Carlssonb170d0c2008-02-05 20:01:53 +00002003 }
Mike Stump11289f42009-09-09 15:08:12 +00002004
Chris Lattnerd9725f72009-04-26 07:16:29 +00002005 if (Info.isReadWrite()) {
Anders Carlssonb170d0c2008-02-05 20:01:53 +00002006 InOutConstraints += ',';
Anders Carlssonda5f5692009-01-11 19:32:54 +00002007
Anders Carlsson56388952009-08-04 18:18:36 +00002008 const Expr *InputExpr = S.getOutputExpr(i);
Chad Rosier59df25b2012-08-23 20:00:18 +00002009 llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(),
Nick Lewycky2d84e842013-10-02 02:29:49 +00002010 InOutConstraints,
2011 InputExpr->getExprLoc());
Mike Stump11289f42009-09-09 15:08:12 +00002012
Bill Wendling3b9eaa12012-03-22 23:25:07 +00002013 if (llvm::Type* AdjTy =
Tim Northover0ae93912013-06-07 00:04:50 +00002014 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint,
2015 Arg->getType()))
Bill Wendling3b9eaa12012-03-22 23:25:07 +00002016 Arg = Builder.CreateBitCast(Arg, AdjTy);
2017
Craig Topper2a873142018-08-14 20:21:05 +00002018 // Update largest vector width for any vector types.
2019 if (auto *VT = dyn_cast<llvm::VectorType>(Arg->getType()))
2020 LargestVectorWidth = std::max(LargestVectorWidth,
2021 VT->getPrimitiveSizeInBits());
Chris Lattnerd9725f72009-04-26 07:16:29 +00002022 if (Info.allowsRegister())
Anders Carlsson431acd12009-01-11 21:23:27 +00002023 InOutConstraints += llvm::utostr(i);
2024 else
2025 InOutConstraints += OutputConstraint;
Anders Carlssona948c342009-01-11 19:46:50 +00002026
Anders Carlsson56388952009-08-04 18:18:36 +00002027 InOutArgTypes.push_back(Arg->getType());
2028 InOutArgs.push_back(Arg);
Anders Carlssonb170d0c2008-02-05 20:01:53 +00002029 }
Anders Carlsson952a9952008-02-05 16:35:33 +00002030 }
Mike Stump11289f42009-09-09 15:08:12 +00002031
Reid Kleckner9b3e3df2014-09-04 20:04:38 +00002032 // If this is a Microsoft-style asm blob, store the return registers (EAX:EDX)
2033 // to the return value slot. Only do this when returning in registers.
2034 if (isa<MSAsmStmt>(&S)) {
2035 const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo();
2036 if (RetAI.isDirect() || RetAI.isExtend()) {
2037 // Make a fake lvalue for the return value slot.
2038 LValue ReturnSlot = MakeAddrLValue(ReturnValue, FnRetTy);
2039 CGM.getTargetCodeGenInfo().addReturnRegisterOutputs(
2040 *this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes,
2041 ResultRegDests, AsmString, S.getNumOutputs());
2042 SawAsmBlock = true;
2043 }
2044 }
Mike Stump11289f42009-09-09 15:08:12 +00002045
Anders Carlsson952a9952008-02-05 16:35:33 +00002046 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
2047 const Expr *InputExpr = S.getInputExpr(i);
2048
Chris Lattner17769a32009-05-03 07:05:00 +00002049 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
2050
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00002051 if (Info.allowsMemory())
2052 ReadNone = false;
2053
Chris Lattner10f221f2009-05-03 07:53:25 +00002054 if (!Constraints.empty())
Anders Carlsson952a9952008-02-05 16:35:33 +00002055 Constraints += ',';
Mike Stump11289f42009-09-09 15:08:12 +00002056
Anders Carlsson952a9952008-02-05 16:35:33 +00002057 // Simplify the input constraint.
Chris Lattner17769a32009-05-03 07:05:00 +00002058 std::string InputConstraint(S.getInputConstraint(i));
John McCallc8e01702013-04-16 22:48:15 +00002059 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(),
Chris Lattnerc16d4762009-04-26 17:57:12 +00002060 &OutputConstraintInfos);
Anders Carlsson952a9952008-02-05 16:35:33 +00002061
Eric Christopher79f5e4e2015-02-06 18:44:18 +00002062 InputConstraint = AddVariableConstraints(
2063 InputConstraint, *InputExpr->IgnoreParenNoopCasts(getContext()),
2064 getTarget(), CGM, S, false /* No EarlyClobber */);
Rafael Espindolac56f8472010-12-30 22:59:32 +00002065
Chad Rosier59df25b2012-08-23 20:00:18 +00002066 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
Mike Stump11289f42009-09-09 15:08:12 +00002067
Chris Lattnerb65933e2009-05-03 07:27:51 +00002068 // If this input argument is tied to a larger output result, extend the
2069 // input to be the same size as the output. The LLVM backend wants to see
2070 // the input and output of a matching constraint be the same size. Note
2071 // that GCC does not define what the top bits are here. We use zext because
2072 // that is usually cheaper, but LLVM IR should really get an anyext someday.
2073 if (Info.hasTiedOperand()) {
2074 unsigned Output = Info.getTiedOperand();
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00002075 QualType OutputType = S.getOutputExpr(Output)->getType();
Chris Lattnerb65933e2009-05-03 07:27:51 +00002076 QualType InputTy = InputExpr->getType();
Mike Stump11289f42009-09-09 15:08:12 +00002077
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00002078 if (getContext().getTypeSize(OutputType) >
Chris Lattnerb65933e2009-05-03 07:27:51 +00002079 getContext().getTypeSize(InputTy)) {
2080 // Use ptrtoint as appropriate so that we can do our extension.
2081 if (isa<llvm::PointerType>(Arg->getType()))
Chris Lattner5e016ae2010-06-27 07:15:29 +00002082 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy);
Chris Lattner2192fe52011-07-18 04:24:23 +00002083 llvm::Type *OutputTy = ConvertType(OutputType);
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00002084 if (isa<llvm::IntegerType>(OutputTy))
2085 Arg = Builder.CreateZExt(Arg, OutputTy);
Peter Collingbourne05500ba2011-07-29 00:24:50 +00002086 else if (isa<llvm::PointerType>(OutputTy))
2087 Arg = Builder.CreateZExt(Arg, IntPtrTy);
2088 else {
2089 assert(OutputTy->isFloatingPointTy() && "Unexpected output type");
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00002090 Arg = Builder.CreateFPExt(Arg, OutputTy);
Peter Collingbourne05500ba2011-07-29 00:24:50 +00002091 }
Chris Lattnerb65933e2009-05-03 07:27:51 +00002092 }
2093 }
Bill Wendling3b9eaa12012-03-22 23:25:07 +00002094 if (llvm::Type* AdjTy =
Peter Collingbourne8f5cf742011-02-19 23:03:58 +00002095 getTargetHooks().adjustInlineAsmType(*this, InputConstraint,
2096 Arg->getType()))
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00002097 Arg = Builder.CreateBitCast(Arg, AdjTy);
Tim Northover0ae93912013-06-07 00:04:50 +00002098 else
2099 CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input)
2100 << InputExpr->getType() << InputConstraint;
Mike Stump11289f42009-09-09 15:08:12 +00002101
Craig Topper2a873142018-08-14 20:21:05 +00002102 // Update largest vector width for any vector types.
2103 if (auto *VT = dyn_cast<llvm::VectorType>(Arg->getType()))
2104 LargestVectorWidth = std::max(LargestVectorWidth,
2105 VT->getPrimitiveSizeInBits());
2106
Anders Carlsson952a9952008-02-05 16:35:33 +00002107 ArgTypes.push_back(Arg->getType());
2108 Args.push_back(Arg);
2109 Constraints += InputConstraint;
2110 }
Mike Stump11289f42009-09-09 15:08:12 +00002111
Anders Carlssonb170d0c2008-02-05 20:01:53 +00002112 // Append the "input" part of inout constraints last.
2113 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
2114 ArgTypes.push_back(InOutArgTypes[i]);
2115 Args.push_back(InOutArgs[i]);
2116 }
2117 Constraints += InOutConstraints;
Mike Stump11289f42009-09-09 15:08:12 +00002118
Anders Carlsson952a9952008-02-05 16:35:33 +00002119 // Clobbers
2120 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
Chad Rosier6100ae12012-08-27 23:47:56 +00002121 StringRef Clobber = S.getClobber(i);
Anders Carlsson952a9952008-02-05 16:35:33 +00002122
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00002123 if (Clobber == "memory")
2124 ReadOnly = ReadNone = false;
2125 else if (Clobber != "cc")
Reid Kleckner9b3e3df2014-09-04 20:04:38 +00002126 Clobber = getTarget().getNormalizedGCCRegisterName(Clobber);
Mike Stump11289f42009-09-09 15:08:12 +00002127
Reid Kleckner9b3e3df2014-09-04 20:04:38 +00002128 if (!Constraints.empty())
Anders Carlsson952a9952008-02-05 16:35:33 +00002129 Constraints += ',';
Mike Stump11289f42009-09-09 15:08:12 +00002130
Anders Carlsson3ed4aea2008-02-06 00:11:32 +00002131 Constraints += "~{";
Anders Carlsson952a9952008-02-05 16:35:33 +00002132 Constraints += Clobber;
Anders Carlsson3ed4aea2008-02-06 00:11:32 +00002133 Constraints += '}';
Anders Carlsson952a9952008-02-05 16:35:33 +00002134 }
Mike Stump11289f42009-09-09 15:08:12 +00002135
Anders Carlsson952a9952008-02-05 16:35:33 +00002136 // Add machine specific clobbers
John McCallc8e01702013-04-16 22:48:15 +00002137 std::string MachineClobbers = getTarget().getClobbers();
Eli Friedmandea41932008-12-21 01:15:32 +00002138 if (!MachineClobbers.empty()) {
Anders Carlsson952a9952008-02-05 16:35:33 +00002139 if (!Constraints.empty())
2140 Constraints += ',';
Eli Friedmandea41932008-12-21 01:15:32 +00002141 Constraints += MachineClobbers;
Anders Carlsson952a9952008-02-05 16:35:33 +00002142 }
Anders Carlssonb4e46322009-05-01 00:16:04 +00002143
Chris Lattner2192fe52011-07-18 04:24:23 +00002144 llvm::Type *ResultType;
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002145 if (ResultRegTypes.empty())
Chris Lattnerece04092012-02-07 00:39:47 +00002146 ResultType = VoidTy;
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002147 else if (ResultRegTypes.size() == 1)
2148 ResultType = ResultRegTypes[0];
Anders Carlssonb4e46322009-05-01 00:16:04 +00002149 else
John McCallad7c5c12011-02-08 08:22:06 +00002150 ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes);
Mike Stump11289f42009-09-09 15:08:12 +00002151
Chris Lattner2192fe52011-07-18 04:24:23 +00002152 llvm::FunctionType *FTy =
Anders Carlsson952a9952008-02-05 16:35:33 +00002153 llvm::FunctionType::get(ResultType, ArgTypes, false);
Mike Stump11289f42009-09-09 15:08:12 +00002154
Chad Rosier7ea9ce72012-09-04 19:50:17 +00002155 bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0;
Chad Rosier7cf5a442012-09-05 19:01:07 +00002156 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?
2157 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
Mike Stump11289f42009-09-09 15:08:12 +00002158 llvm::InlineAsm *IA =
Chad Rosiereb31ef02012-09-04 23:08:24 +00002159 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
Chad Rosier7cf5a442012-09-05 19:01:07 +00002160 /* IsAlignStack */ false, AsmDialect);
Reid Klecknerb75a3f02018-02-09 00:16:41 +00002161 llvm::CallInst *Result =
2162 Builder.CreateCall(IA, Args, getBundlesForFunclet(IA));
Reid Klecknerde864822017-03-21 16:57:30 +00002163 Result->addAttribute(llvm::AttributeList::FunctionIndex,
Peter Collingbourne2ee0b632013-03-02 01:20:22 +00002164 llvm::Attribute::NoUnwind);
Mike Stump11289f42009-09-09 15:08:12 +00002165
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00002166 // Attach readnone and readonly attributes.
2167 if (!HasSideEffect) {
2168 if (ReadNone)
Reid Klecknerde864822017-03-21 16:57:30 +00002169 Result->addAttribute(llvm::AttributeList::FunctionIndex,
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00002170 llvm::Attribute::ReadNone);
2171 else if (ReadOnly)
Reid Klecknerde864822017-03-21 16:57:30 +00002172 Result->addAttribute(llvm::AttributeList::FunctionIndex,
Akira Hatanaka10bdb2b2015-07-10 18:44:40 +00002173 llvm::Attribute::ReadOnly);
2174 }
2175
Chris Lattnerfdb76cc2010-04-07 05:46:54 +00002176 // Slap the source location of the inline asm into a !srcloc metadata on the
Reid Kleckner4db32562014-07-28 23:12:59 +00002177 // call.
2178 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S)) {
Chad Rosier6051bb92012-08-28 18:54:39 +00002179 Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(),
2180 *this));
Reid Kleckner4db32562014-07-28 23:12:59 +00002181 } else {
2182 // At least put the line number on MS inline asm blobs.
2183 auto Loc = llvm::ConstantInt::get(Int32Ty, S.getAsmLoc().getRawEncoding());
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002184 Result->setMetadata("srcloc",
2185 llvm::MDNode::get(getLLVMContext(),
2186 llvm::ConstantAsMetadata::get(Loc)));
Reid Kleckner4db32562014-07-28 23:12:59 +00002187 }
Mike Stump11289f42009-09-09 15:08:12 +00002188
Matt Arsenaulta5888a72017-11-13 22:40:55 +00002189 if (getLangOpts().assumeFunctionsAreConvergent()) {
2190 // Conservatively, mark all inline asm blocks in CUDA or OpenCL as
2191 // convergent (meaning, they may call an intrinsically convergent op, such
2192 // as bar.sync, and so can't have certain optimizations applied around
2193 // them).
Reid Klecknerde864822017-03-21 16:57:30 +00002194 Result->addAttribute(llvm::AttributeList::FunctionIndex,
Justin Lebarf1793642016-05-31 21:27:13 +00002195 llvm::Attribute::Convergent);
2196 }
2197
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002198 // Extract all of the register value results from the asm.
2199 std::vector<llvm::Value*> RegResults;
2200 if (ResultRegTypes.size() == 1) {
2201 RegResults.push_back(Result);
Anders Carlssonb4e46322009-05-01 00:16:04 +00002202 } else {
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002203 for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
Anders Carlssonb4e46322009-05-01 00:16:04 +00002204 llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult");
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002205 RegResults.push_back(Tmp);
Anders Carlssonb4e46322009-05-01 00:16:04 +00002206 }
2207 }
Mike Stump11289f42009-09-09 15:08:12 +00002208
Reid Kleckner9b3e3df2014-09-04 20:04:38 +00002209 assert(RegResults.size() == ResultRegTypes.size());
2210 assert(RegResults.size() == ResultTruncRegTypes.size());
2211 assert(RegResults.size() == ResultRegDests.size());
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002212 for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {
2213 llvm::Value *Tmp = RegResults[i];
Mike Stump11289f42009-09-09 15:08:12 +00002214
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002215 // If the result type of the LLVM IR asm doesn't match the result type of
2216 // the expression, do the conversion.
2217 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
Chris Lattner2192fe52011-07-18 04:24:23 +00002218 llvm::Type *TruncTy = ResultTruncRegTypes[i];
Chad Rosierbebf1462012-06-20 17:43:05 +00002219
Chris Lattnerdb6d5cb2010-04-23 17:27:29 +00002220 // Truncate the integer result to the right size, note that TruncTy can be
2221 // a pointer.
2222 if (TruncTy->isFloatingPointTy())
2223 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy);
Dan Gohman7905d182010-04-24 04:55:02 +00002224 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
Micah Villmowdd31ca12012-10-08 16:25:52 +00002225 uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy);
John McCallad7c5c12011-02-08 08:22:06 +00002226 Tmp = Builder.CreateTrunc(Tmp,
2227 llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize));
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002228 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy);
Dan Gohman7905d182010-04-24 04:55:02 +00002229 } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
Micah Villmowdd31ca12012-10-08 16:25:52 +00002230 uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType());
John McCallad7c5c12011-02-08 08:22:06 +00002231 Tmp = Builder.CreatePtrToInt(Tmp,
2232 llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize));
Dan Gohman7905d182010-04-24 04:55:02 +00002233 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
2234 } else if (TruncTy->isIntegerTy()) {
Simon Pilgrimbbef124e2017-09-12 11:05:42 +00002235 Tmp = Builder.CreateZExtOrTrunc(Tmp, TruncTy);
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00002236 } else if (TruncTy->isVectorTy()) {
2237 Tmp = Builder.CreateBitCast(Tmp, TruncTy);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002238 }
2239 }
Mike Stump11289f42009-09-09 15:08:12 +00002240
John McCall55e1fbc2011-06-25 02:11:03 +00002241 EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]);
Chris Lattner59c3a9c2009-05-03 08:21:20 +00002242 }
Anders Carlsson952a9952008-02-05 16:35:33 +00002243}
Tareq A. Siraj24110cc2013-04-16 18:53:08 +00002244
Alexey Bataev330de032014-10-29 12:21:55 +00002245LValue CodeGenFunction::InitCapturedStruct(const CapturedStmt &S) {
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002246 const RecordDecl *RD = S.getCapturedRecordDecl();
Alexey Bataev330de032014-10-29 12:21:55 +00002247 QualType RecordTy = getContext().getRecordType(RD);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002248
2249 // Initialize the captured struct.
John McCall7f416cc2015-09-08 08:05:57 +00002250 LValue SlotLV =
2251 MakeAddrLValue(CreateMemTemp(RecordTy, "agg.captured"), RecordTy);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002252
2253 RecordDecl::field_iterator CurField = RD->field_begin();
James Y Knight53c76162015-07-17 18:21:37 +00002254 for (CapturedStmt::const_capture_init_iterator I = S.capture_init_begin(),
2255 E = S.capture_init_end();
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002256 I != E; ++I, ++CurField) {
Alexey Bataev330de032014-10-29 12:21:55 +00002257 LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField);
2258 if (CurField->hasCapturedVLAType()) {
2259 auto VAT = CurField->getCapturedVLAType();
2260 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2261 } else {
Richard Smith30e304e2016-12-14 00:03:17 +00002262 EmitInitializerForField(*CurField, LV, *I);
Alexey Bataev330de032014-10-29 12:21:55 +00002263 }
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002264 }
2265
2266 return SlotLV;
2267}
2268
2269/// Generate an outlined function for the body of a CapturedStmt, store any
2270/// captured variables into the captured struct, and call the outlined function.
2271llvm::Function *
2272CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) {
Alexey Bataev330de032014-10-29 12:21:55 +00002273 LValue CapStruct = InitCapturedStruct(S);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002274
2275 // Emit the CapturedDecl
2276 CodeGenFunction CGF(CGM, true);
Alexey Bataevd157d472015-06-24 03:35:38 +00002277 CGCapturedStmtRAII CapInfoRAII(CGF, new CGCapturedStmtInfo(S, K));
Alexey Bataevaca7fcf2014-06-30 02:55:54 +00002278 llvm::Function *F = CGF.GenerateCapturedStmtFunction(S);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002279 delete CGF.CapturedStmtInfo;
2280
2281 // Emit call to the helper function.
John McCall7f416cc2015-09-08 08:05:57 +00002282 EmitCallOrInvoke(F, CapStruct.getPointer());
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002283
2284 return F;
2285}
2286
John McCall7f416cc2015-09-08 08:05:57 +00002287Address CodeGenFunction::GenerateCapturedStmtArgument(const CapturedStmt &S) {
Alexey Bataev330de032014-10-29 12:21:55 +00002288 LValue CapStruct = InitCapturedStruct(S);
Alexey Bataev9959db52014-05-06 10:08:46 +00002289 return CapStruct.getAddress();
2290}
2291
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002292/// Creates the outlined function for a CapturedStmt.
2293llvm::Function *
Alexey Bataevaca7fcf2014-06-30 02:55:54 +00002294CodeGenFunction::GenerateCapturedStmtFunction(const CapturedStmt &S) {
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002295 assert(CapturedStmtInfo &&
2296 "CapturedStmtInfo should be set when generating the captured function");
Alexey Bataevaca7fcf2014-06-30 02:55:54 +00002297 const CapturedDecl *CD = S.getCapturedDecl();
2298 const RecordDecl *RD = S.getCapturedRecordDecl();
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002299 SourceLocation Loc = S.getBeginLoc();
Alexey Bataevaca7fcf2014-06-30 02:55:54 +00002300 assert(CD->hasBody() && "missing CapturedDecl body");
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002301
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002302 // Build the argument list.
2303 ASTContext &Ctx = CGM.getContext();
2304 FunctionArgList Args;
2305 Args.append(CD->param_begin(), CD->param_end());
2306
2307 // Create the function declaration.
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002308 const CGFunctionInfo &FuncInfo =
John McCallc56a8b32016-03-11 04:30:31 +00002309 CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002310 llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo);
2311
2312 llvm::Function *F =
2313 llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,
2314 CapturedStmtInfo->getHelperName(), &CGM.getModule());
2315 CGM.SetInternalFunctionAttributes(CD, F, FuncInfo);
Alexey Bataev36bf0112015-03-10 05:15:26 +00002316 if (CD->isNothrow())
2317 F->addFnAttr(llvm::Attribute::NoUnwind);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002318
2319 // Generate the function.
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002320 StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getLocation(),
2321 CD->getBody()->getBeginLoc());
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002322 // Set the context parameter in CapturedStmtInfo.
John McCall7f416cc2015-09-08 08:05:57 +00002323 Address DeclPtr = GetAddrOfLocalVar(CD->getContextParam());
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002324 CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr));
2325
Alexey Bataevaca7fcf2014-06-30 02:55:54 +00002326 // Initialize variable-length arrays.
Alexey Bataev330de032014-10-29 12:21:55 +00002327 LValue Base = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(),
2328 Ctx.getTagDeclType(RD));
2329 for (auto *FD : RD->fields()) {
2330 if (FD->hasCapturedVLAType()) {
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002331 auto *ExprArg =
2332 EmitLoadOfLValue(EmitLValueForField(Base, FD), S.getBeginLoc())
2333 .getScalarVal();
Alexey Bataev330de032014-10-29 12:21:55 +00002334 auto VAT = FD->getCapturedVLAType();
2335 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
2336 }
2337 }
Alexey Bataevaca7fcf2014-06-30 02:55:54 +00002338
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002339 // If 'this' is captured, load it into CXXThisValue.
2340 if (CapturedStmtInfo->isCXXThisExprCaptured()) {
2341 FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl();
Alexey Bataev330de032014-10-29 12:21:55 +00002342 LValue ThisLValue = EmitLValueForField(Base, FD);
Nick Lewycky2d84e842013-10-02 02:29:49 +00002343 CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal();
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002344 }
2345
Serge Pavlov3a561452015-12-06 14:32:39 +00002346 PGO.assignRegionCounters(GlobalDecl(CD), F);
Ben Langmuir3b4c30b2013-05-09 19:17:11 +00002347 CapturedStmtInfo->EmitBody(*this, CD->getBody());
2348 FinishFunction(CD->getBodyRBrace());
2349
2350 return F;
Tareq A. Siraj24110cc2013-04-16 18:53:08 +00002351}