Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(267)

Side by Side Diff: test/cctest/compiler/test-osr.cc

Issue 2395783002: Revert of [turbofan] Osr value typing + dynamic type checks on entry. (Closed)
Patch Set: Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « test/cctest/cctest.gyp ('k') | test/mjsunit/compiler/osr-typing-debug-change.js » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2015 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "src/codegen.h"
6 #include "src/compiler/all-nodes.h"
7 #include "src/compiler/common-operator.h"
8 #include "src/compiler/diamond.h"
9 #include "src/compiler/graph.h"
10 #include "src/compiler/js-graph.h"
11 #include "src/compiler/js-operator.h"
12 #include "src/compiler/operator.h"
13 #include "src/compiler/osr.h"
14 #include "test/cctest/cctest.h"
15
16 namespace v8 {
17 namespace internal {
18 namespace compiler {
19
20 // TODO(titzer): move this method to a common testing place.
21
22 static int CheckInputs(Node* node, Node* i0 = NULL, Node* i1 = NULL,
23 Node* i2 = NULL, Node* i3 = NULL) {
24 int count = 4;
25 if (i3 == NULL) count = 3;
26 if (i2 == NULL) count = 2;
27 if (i1 == NULL) count = 1;
28 if (i0 == NULL) count = 0;
29 CHECK_EQ(count, node->InputCount());
30 if (i0 != NULL) CHECK_EQ(i0, node->InputAt(0));
31 if (i1 != NULL) CHECK_EQ(i1, node->InputAt(1));
32 if (i2 != NULL) CHECK_EQ(i2, node->InputAt(2));
33 if (i3 != NULL) CHECK_EQ(i3, node->InputAt(3));
34 return count;
35 }
36
37
38 static Operator kIntLt(IrOpcode::kInt32LessThan, Operator::kPure,
39 "Int32LessThan", 2, 0, 0, 1, 0, 0);
40 static Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0,
41 0, 1, 0, 0);
42
43
44 static const int kMaxOsrValues = 10;
45
46 class OsrDeconstructorTester : public HandleAndZoneScope {
47 public:
48 explicit OsrDeconstructorTester(int num_values)
49 : isolate(main_isolate()),
50 common(main_zone()),
51 graph(main_zone()),
52 jsgraph(main_isolate(), &graph, &common, nullptr, nullptr, nullptr),
53 start(graph.NewNode(common.Start(1))),
54 p0(graph.NewNode(common.Parameter(0), start)),
55 end(graph.NewNode(common.End(1), start)),
56 osr_normal_entry(graph.NewNode(common.OsrNormalEntry(), start, start)),
57 osr_loop_entry(graph.NewNode(common.OsrLoopEntry(), start, start)),
58 self(graph.NewNode(common.Int32Constant(0xaabbccdd))) {
59 CHECK(num_values <= kMaxOsrValues);
60 graph.SetStart(start);
61 for (int i = 0; i < num_values; i++) {
62 osr_values[i] = graph.NewNode(common.OsrValue(i), osr_loop_entry);
63 }
64 }
65
66 Isolate* isolate;
67 CommonOperatorBuilder common;
68 Graph graph;
69 JSGraph jsgraph;
70 Node* start;
71 Node* p0;
72 Node* end;
73 Node* osr_normal_entry;
74 Node* osr_loop_entry;
75 Node* self;
76 Node* osr_values[kMaxOsrValues];
77
78 Node* NewOsrPhi(Node* loop, Node* incoming, int osr_value, Node* back1 = NULL,
79 Node* back2 = NULL, Node* back3 = NULL) {
80 int count = 5;
81 if (back3 == NULL) count = 4;
82 if (back2 == NULL) count = 3;
83 if (back1 == NULL) count = 2;
84 CHECK_EQ(loop->InputCount(), count);
85 CHECK_EQ(osr_loop_entry, loop->InputAt(1));
86
87 Node* inputs[6];
88 inputs[0] = incoming;
89 inputs[1] = osr_values[osr_value];
90 if (count > 2) inputs[2] = back1;
91 if (count > 3) inputs[3] = back2;
92 if (count > 4) inputs[4] = back3;
93 inputs[count] = loop;
94 return graph.NewNode(common.Phi(MachineRepresentation::kTagged, count),
95 count + 1, inputs);
96 }
97
98 Node* NewLoop(bool is_osr, int num_backedges, Node* entry = nullptr) {
99 if (entry == nullptr) entry = osr_normal_entry;
100 Node* loop = graph.NewNode(common.Loop(1), entry);
101 if (is_osr) {
102 loop->AppendInput(graph.zone(), osr_loop_entry);
103 }
104 for (int i = 0; i < num_backedges; i++) {
105 loop->AppendInput(graph.zone(), loop);
106 }
107 NodeProperties::ChangeOp(loop, common.Loop(loop->InputCount()));
108 return loop;
109 }
110
111 Node* NewOsrLoop(int num_backedges, Node* entry = NULL) {
112 return NewLoop(true, num_backedges, entry);
113 }
114
115 void DeconstructOsr() {
116 OsrHelper helper(0, 0);
117 helper.Deconstruct(&jsgraph, &common, main_zone());
118 AllNodes nodes(main_zone(), &graph);
119 // Should be edited out.
120 CHECK(!nodes.IsLive(osr_normal_entry));
121 CHECK(!nodes.IsLive(osr_loop_entry));
122 // No dangling nodes should be left over.
123 for (Node* const node : nodes.reachable) {
124 for (Node* const use : node->uses()) {
125 CHECK(std::find(nodes.reachable.begin(), nodes.reachable.end(), use) !=
126 nodes.reachable.end());
127 }
128 }
129 }
130 };
131
132
133 TEST(Deconstruct_osr0) {
134 OsrDeconstructorTester T(0);
135
136 Node* loop = T.NewOsrLoop(1);
137
138 T.graph.SetEnd(loop);
139
140 T.DeconstructOsr();
141
142 CheckInputs(loop, T.start, loop);
143 }
144
145
146 TEST(Deconstruct_osr1) {
147 OsrDeconstructorTester T(1);
148
149 Node* loop = T.NewOsrLoop(1);
150 Node* osr_phi =
151 T.NewOsrPhi(loop, T.jsgraph.OneConstant(), 0, T.jsgraph.ZeroConstant());
152
153 Node* ret = T.graph.NewNode(T.common.Return(), osr_phi, T.start, loop);
154 T.graph.SetEnd(ret);
155
156 T.DeconstructOsr();
157
158 CheckInputs(loop, T.start, loop);
159 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.ZeroConstant(), loop);
160 CheckInputs(ret, osr_phi, T.start, loop);
161 }
162
163
164 TEST(Deconstruct_osr_remove_prologue) {
165 OsrDeconstructorTester T(1);
166 Diamond d(&T.graph, &T.common, T.p0);
167 d.Chain(T.osr_normal_entry);
168
169 Node* loop = T.NewOsrLoop(1, d.merge);
170 Node* osr_phi =
171 T.NewOsrPhi(loop, T.jsgraph.OneConstant(), 0, T.jsgraph.ZeroConstant());
172
173 Node* ret = T.graph.NewNode(T.common.Return(), osr_phi, T.start, loop);
174 T.graph.SetEnd(ret);
175
176 T.DeconstructOsr();
177
178 CheckInputs(loop, T.start, loop);
179 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.ZeroConstant(), loop);
180 CheckInputs(ret, osr_phi, T.start, loop);
181
182 // The control before the loop should have been removed.
183 AllNodes nodes(T.main_zone(), &T.graph);
184 CHECK(!nodes.IsLive(d.branch));
185 CHECK(!nodes.IsLive(d.if_true));
186 CHECK(!nodes.IsLive(d.if_false));
187 CHECK(!nodes.IsLive(d.merge));
188 }
189
190
191 TEST(Deconstruct_osr_with_body1) {
192 OsrDeconstructorTester T(1);
193
194 Node* loop = T.NewOsrLoop(1);
195
196 Node* branch = T.graph.NewNode(T.common.Branch(), T.p0, loop);
197 Node* if_true = T.graph.NewNode(T.common.IfTrue(), branch);
198 Node* if_false = T.graph.NewNode(T.common.IfFalse(), branch);
199 loop->ReplaceInput(2, if_true);
200
201 Node* osr_phi =
202 T.NewOsrPhi(loop, T.jsgraph.OneConstant(), 0, T.jsgraph.ZeroConstant());
203
204 Node* ret = T.graph.NewNode(T.common.Return(), osr_phi, T.start, if_false);
205 T.graph.SetEnd(ret);
206
207 T.DeconstructOsr();
208
209 CheckInputs(loop, T.start, if_true);
210 CheckInputs(branch, T.p0, loop);
211 CheckInputs(if_true, branch);
212 CheckInputs(if_false, branch);
213 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.ZeroConstant(), loop);
214 CheckInputs(ret, osr_phi, T.start, if_false);
215 }
216
217
218 TEST(Deconstruct_osr_with_body2) {
219 OsrDeconstructorTester T(1);
220
221 Node* loop = T.NewOsrLoop(1);
222
223 // Two chained branches in the the body of the loop.
224 Node* branch1 = T.graph.NewNode(T.common.Branch(), T.p0, loop);
225 Node* if_true1 = T.graph.NewNode(T.common.IfTrue(), branch1);
226 Node* if_false1 = T.graph.NewNode(T.common.IfFalse(), branch1);
227
228 Node* branch2 = T.graph.NewNode(T.common.Branch(), T.p0, if_true1);
229 Node* if_true2 = T.graph.NewNode(T.common.IfTrue(), branch2);
230 Node* if_false2 = T.graph.NewNode(T.common.IfFalse(), branch2);
231 loop->ReplaceInput(2, if_true2);
232
233 Node* osr_phi =
234 T.NewOsrPhi(loop, T.jsgraph.OneConstant(), 0, T.jsgraph.ZeroConstant());
235
236 Node* merge = T.graph.NewNode(T.common.Merge(2), if_false1, if_false2);
237 Node* ret = T.graph.NewNode(T.common.Return(), osr_phi, T.start, merge);
238 T.graph.SetEnd(ret);
239
240 T.DeconstructOsr();
241
242 CheckInputs(loop, T.start, if_true2);
243 CheckInputs(branch1, T.p0, loop);
244 CheckInputs(branch2, T.p0, if_true1);
245 CheckInputs(if_true1, branch1);
246 CheckInputs(if_false1, branch1);
247 CheckInputs(if_true2, branch2);
248 CheckInputs(if_false2, branch2);
249
250 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.ZeroConstant(), loop);
251 CheckInputs(ret, osr_phi, T.start, merge);
252 CheckInputs(merge, if_false1, if_false2);
253 }
254
255
256 TEST(Deconstruct_osr_with_body3) {
257 OsrDeconstructorTester T(1);
258
259 Node* loop = T.NewOsrLoop(2);
260
261 // Two branches that create two different backedges.
262 Node* branch1 = T.graph.NewNode(T.common.Branch(), T.p0, loop);
263 Node* if_true1 = T.graph.NewNode(T.common.IfTrue(), branch1);
264 Node* if_false1 = T.graph.NewNode(T.common.IfFalse(), branch1);
265
266 Node* branch2 = T.graph.NewNode(T.common.Branch(), T.p0, if_true1);
267 Node* if_true2 = T.graph.NewNode(T.common.IfTrue(), branch2);
268 Node* if_false2 = T.graph.NewNode(T.common.IfFalse(), branch2);
269 loop->ReplaceInput(2, if_false1);
270 loop->ReplaceInput(3, if_true2);
271
272 Node* osr_phi =
273 T.NewOsrPhi(loop, T.jsgraph.OneConstant(), 0, T.jsgraph.ZeroConstant(),
274 T.jsgraph.ZeroConstant());
275
276 Node* ret = T.graph.NewNode(T.common.Return(), osr_phi, T.start, if_false2);
277 T.graph.SetEnd(ret);
278
279 T.DeconstructOsr();
280
281 CheckInputs(loop, T.start, if_false1, if_true2);
282 CheckInputs(branch1, T.p0, loop);
283 CheckInputs(branch2, T.p0, if_true1);
284 CheckInputs(if_true1, branch1);
285 CheckInputs(if_false1, branch1);
286 CheckInputs(if_true2, branch2);
287 CheckInputs(if_false2, branch2);
288
289 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.ZeroConstant(),
290 T.jsgraph.ZeroConstant(), loop);
291 CheckInputs(ret, osr_phi, T.start, if_false2);
292 }
293
294
295 struct While {
296 OsrDeconstructorTester& t;
297 Node* branch;
298 Node* if_true;
299 Node* exit;
300 Node* loop;
301
302 While(OsrDeconstructorTester& R, Node* cond, bool is_osr, int backedges = 1)
303 : t(R) {
304 loop = t.NewLoop(is_osr, backedges);
305 branch = t.graph.NewNode(t.common.Branch(), cond, loop);
306 if_true = t.graph.NewNode(t.common.IfTrue(), branch);
307 exit = t.graph.NewNode(t.common.IfFalse(), branch);
308 loop->ReplaceInput(loop->InputCount() - 1, if_true);
309 }
310
311 void Nest(While& that) {
312 that.loop->ReplaceInput(that.loop->InputCount() - 1, exit);
313 this->loop->ReplaceInput(0, that.if_true);
314 }
315
316 Node* Phi(Node* i1, Node* i2, Node* i3) {
317 if (loop->InputCount() == 2) {
318 return t.graph.NewNode(t.common.Phi(MachineRepresentation::kTagged, 2),
319 i1, i2, loop);
320 } else {
321 return t.graph.NewNode(t.common.Phi(MachineRepresentation::kTagged, 3),
322 i1, i2, i3, loop);
323 }
324 }
325 };
326
327
328 static Node* FindSuccessor(Node* node, IrOpcode::Value opcode) {
329 for (Node* use : node->uses()) {
330 if (use->opcode() == opcode) return use;
331 }
332 UNREACHABLE(); // should have been found.
333 return nullptr;
334 }
335
336
337 TEST(Deconstruct_osr_nested1) {
338 OsrDeconstructorTester T(1);
339
340 While outer(T, T.p0, false);
341 While inner(T, T.p0, true);
342 inner.Nest(outer);
343
344 Node* outer_phi = outer.Phi(T.p0, T.p0, nullptr);
345 outer.branch->ReplaceInput(0, outer_phi);
346
347 Node* osr_phi = inner.Phi(T.jsgraph.TrueConstant(), T.osr_values[0],
348 T.jsgraph.FalseConstant());
349 inner.branch->ReplaceInput(0, osr_phi);
350 outer_phi->ReplaceInput(1, osr_phi);
351
352 Node* ret =
353 T.graph.NewNode(T.common.Return(), outer_phi, T.start, outer.exit);
354 Node* end = T.graph.NewNode(T.common.End(1), ret);
355 T.graph.SetEnd(end);
356
357 T.DeconstructOsr();
358
359 // Check structure of deconstructed graph.
360 // Check inner OSR loop is directly connected to start.
361 CheckInputs(inner.loop, T.start, inner.if_true);
362 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.FalseConstant(), inner.loop);
363
364 // Check control transfer to copy of outer loop.
365 Node* new_outer_loop = FindSuccessor(inner.exit, IrOpcode::kLoop);
366 Node* new_outer_phi = FindSuccessor(new_outer_loop, IrOpcode::kPhi);
367 CHECK_NE(new_outer_loop, outer.loop);
368 CHECK_NE(new_outer_phi, outer_phi);
369
370 CheckInputs(new_outer_loop, inner.exit, new_outer_loop->InputAt(1));
371
372 // Check structure of outer loop.
373 Node* new_outer_branch = FindSuccessor(new_outer_loop, IrOpcode::kBranch);
374 CHECK_NE(new_outer_branch, outer.branch);
375 CheckInputs(new_outer_branch, new_outer_phi, new_outer_loop);
376 Node* new_outer_exit = FindSuccessor(new_outer_branch, IrOpcode::kIfFalse);
377 Node* new_outer_if_true = FindSuccessor(new_outer_branch, IrOpcode::kIfTrue);
378
379 // Check structure of return.
380 end = T.graph.end();
381 Node* new_ret = end->InputAt(0);
382 CHECK_EQ(IrOpcode::kReturn, new_ret->opcode());
383 CheckInputs(new_ret, new_outer_phi, T.start, new_outer_exit);
384
385 // Check structure of inner loop.
386 Node* new_inner_loop = FindSuccessor(new_outer_if_true, IrOpcode::kLoop);
387 Node* new_inner_phi = FindSuccessor(new_inner_loop, IrOpcode::kPhi);
388
389 CheckInputs(new_inner_phi, T.jsgraph.TrueConstant(),
390 T.jsgraph.FalseConstant(), new_inner_loop);
391 CheckInputs(new_outer_phi, osr_phi, new_inner_phi, new_outer_loop);
392 }
393
394
395 TEST(Deconstruct_osr_nested2) {
396 OsrDeconstructorTester T(1);
397
398 // Test multiple backedge outer loop.
399 While outer(T, T.p0, false, 2);
400 While inner(T, T.p0, true);
401 inner.Nest(outer);
402
403 Node* outer_phi = outer.Phi(T.p0, T.p0, T.p0);
404 outer.branch->ReplaceInput(0, outer_phi);
405
406 Node* osr_phi = inner.Phi(T.jsgraph.TrueConstant(), T.osr_values[0],
407 T.jsgraph.FalseConstant());
408 inner.branch->ReplaceInput(0, osr_phi);
409 outer_phi->ReplaceInput(1, osr_phi);
410 outer_phi->ReplaceInput(2, T.jsgraph.FalseConstant());
411
412 Node* x_branch = T.graph.NewNode(T.common.Branch(), osr_phi, inner.exit);
413 Node* x_true = T.graph.NewNode(T.common.IfTrue(), x_branch);
414 Node* x_false = T.graph.NewNode(T.common.IfFalse(), x_branch);
415
416 outer.loop->ReplaceInput(1, x_true);
417 outer.loop->ReplaceInput(2, x_false);
418
419 Node* ret =
420 T.graph.NewNode(T.common.Return(), outer_phi, T.start, outer.exit);
421 Node* end = T.graph.NewNode(T.common.End(1), ret);
422 T.graph.SetEnd(end);
423
424 T.DeconstructOsr();
425
426 // Check structure of deconstructed graph.
427 // Check inner OSR loop is directly connected to start.
428 CheckInputs(inner.loop, T.start, inner.if_true);
429 CheckInputs(osr_phi, T.osr_values[0], T.jsgraph.FalseConstant(), inner.loop);
430
431 // Check control transfer to copy of outer loop.
432 Node* new_merge = FindSuccessor(x_true, IrOpcode::kMerge);
433 CHECK_EQ(new_merge, FindSuccessor(x_false, IrOpcode::kMerge));
434 CheckInputs(new_merge, x_true, x_false);
435
436 Node* new_outer_loop = FindSuccessor(new_merge, IrOpcode::kLoop);
437 Node* new_outer_phi = FindSuccessor(new_outer_loop, IrOpcode::kPhi);
438 CHECK_NE(new_outer_loop, outer.loop);
439 CHECK_NE(new_outer_phi, outer_phi);
440
441 Node* new_entry_phi = FindSuccessor(new_merge, IrOpcode::kPhi);
442 CheckInputs(new_entry_phi, osr_phi, T.jsgraph.FalseConstant(), new_merge);
443
444 CHECK_EQ(new_merge, new_outer_loop->InputAt(0));
445
446 // Check structure of outer loop.
447 Node* new_outer_branch = FindSuccessor(new_outer_loop, IrOpcode::kBranch);
448 CHECK_NE(new_outer_branch, outer.branch);
449 CheckInputs(new_outer_branch, new_outer_phi, new_outer_loop);
450 Node* new_outer_exit = FindSuccessor(new_outer_branch, IrOpcode::kIfFalse);
451 Node* new_outer_if_true = FindSuccessor(new_outer_branch, IrOpcode::kIfTrue);
452
453 // Check structure of return.
454 end = T.graph.end();
455 Node* new_ret = end->InputAt(0);
456 CHECK_EQ(IrOpcode::kReturn, new_ret->opcode());
457 CheckInputs(new_ret, new_outer_phi, T.start, new_outer_exit);
458
459 // Check structure of inner loop.
460 Node* new_inner_loop = FindSuccessor(new_outer_if_true, IrOpcode::kLoop);
461 Node* new_inner_phi = FindSuccessor(new_inner_loop, IrOpcode::kPhi);
462
463 CheckInputs(new_inner_phi, T.jsgraph.TrueConstant(),
464 T.jsgraph.FalseConstant(), new_inner_loop);
465 CheckInputs(new_outer_phi, new_entry_phi, new_inner_phi,
466 T.jsgraph.FalseConstant(), new_outer_loop);
467 }
468
469
470 Node* MakeCounter(JSGraph* jsgraph, Node* start, Node* loop) {
471 int count = loop->InputCount();
472 NodeVector tmp_inputs(jsgraph->graph()->zone());
473 for (int i = 0; i < count; i++) {
474 tmp_inputs.push_back(start);
475 }
476 tmp_inputs.push_back(loop);
477
478 Node* phi = jsgraph->graph()->NewNode(
479 jsgraph->common()->Phi(MachineRepresentation::kWord32, count), count + 1,
480 &tmp_inputs[0]);
481 Node* inc = jsgraph->graph()->NewNode(&kIntAdd, phi, jsgraph->OneConstant());
482
483 for (int i = 1; i < count; i++) {
484 phi->ReplaceInput(i, inc);
485 }
486 return phi;
487 }
488
489
490 TEST(Deconstruct_osr_nested3) {
491 OsrDeconstructorTester T(1);
492
493 // outermost loop.
494 While loop0(T, T.p0, false, 1);
495 Node* loop0_cntr = MakeCounter(&T.jsgraph, T.p0, loop0.loop);
496 loop0.branch->ReplaceInput(0, loop0_cntr);
497
498 // middle loop.
499 Node* loop1 = T.graph.NewNode(T.common.Loop(1), loop0.if_true);
500 Node* loop1_phi =
501 T.graph.NewNode(T.common.Phi(MachineRepresentation::kTagged, 2),
502 loop0_cntr, loop0_cntr, loop1);
503
504 // innermost (OSR) loop.
505 While loop2(T, T.p0, true, 1);
506 loop2.loop->ReplaceInput(0, loop1);
507
508 Node* loop2_cntr = MakeCounter(&T.jsgraph, loop1_phi, loop2.loop);
509 loop2_cntr->ReplaceInput(1, T.osr_values[0]);
510 Node* osr_phi = loop2_cntr;
511 Node* loop2_inc = loop2_cntr->InputAt(2);
512 loop2.branch->ReplaceInput(0, loop2_cntr);
513
514 loop1_phi->ReplaceInput(1, loop2_cntr);
515 loop0_cntr->ReplaceInput(1, loop2_cntr);
516
517 // Branch to either the outer or middle loop.
518 Node* branch = T.graph.NewNode(T.common.Branch(), loop2_cntr, loop2.exit);
519 Node* if_true = T.graph.NewNode(T.common.IfTrue(), branch);
520 Node* if_false = T.graph.NewNode(T.common.IfFalse(), branch);
521
522 loop0.loop->ReplaceInput(1, if_true);
523 loop1->AppendInput(T.graph.zone(), if_false);
524 NodeProperties::ChangeOp(loop1, T.common.Loop(2));
525
526 Node* ret =
527 T.graph.NewNode(T.common.Return(), loop0_cntr, T.start, loop0.exit);
528 Node* end = T.graph.NewNode(T.common.End(1), ret);
529 T.graph.SetEnd(end);
530
531 T.DeconstructOsr();
532
533 // Check structure of deconstructed graph.
534 // Check loop2 (OSR loop) is directly connected to start.
535 CheckInputs(loop2.loop, T.start, loop2.if_true);
536 CheckInputs(osr_phi, T.osr_values[0], loop2_inc, loop2.loop);
537 CheckInputs(loop2.branch, osr_phi, loop2.loop);
538 CheckInputs(loop2.if_true, loop2.branch);
539 CheckInputs(loop2.exit, loop2.branch);
540 CheckInputs(branch, osr_phi, loop2.exit);
541 CheckInputs(if_true, branch);
542 CheckInputs(if_false, branch);
543
544 // Check structure of new_loop1.
545 Node* new_loop1_loop = FindSuccessor(if_false, IrOpcode::kLoop);
546 // TODO(titzer): check the internal copy of loop2.
547 USE(new_loop1_loop);
548
549 // Check structure of new_loop0.
550 Node* new_loop0_loop_entry = FindSuccessor(if_true, IrOpcode::kMerge);
551 Node* new_loop0_loop = FindSuccessor(new_loop0_loop_entry, IrOpcode::kLoop);
552 // TODO(titzer): check the internal copies of loop1 and loop2.
553
554 Node* new_loop0_branch = FindSuccessor(new_loop0_loop, IrOpcode::kBranch);
555 Node* new_loop0_if_true = FindSuccessor(new_loop0_branch, IrOpcode::kIfTrue);
556 Node* new_loop0_exit = FindSuccessor(new_loop0_branch, IrOpcode::kIfFalse);
557
558 USE(new_loop0_if_true);
559
560 Node* new_ret = T.graph.end()->InputAt(0);
561 CHECK_EQ(IrOpcode::kReturn, new_ret->opcode());
562
563 Node* new_loop0_phi = new_ret->InputAt(0);
564 CHECK_EQ(IrOpcode::kPhi, new_loop0_phi->opcode());
565 CHECK_EQ(new_loop0_loop, NodeProperties::GetControlInput(new_loop0_phi));
566 CHECK_EQ(new_loop0_phi, FindSuccessor(new_loop0_loop, IrOpcode::kPhi));
567
568 // Check that the return returns the phi from the OSR loop and control
569 // depends on the copy of the outer loop0.
570 CheckInputs(new_ret, new_loop0_phi, T.graph.start(), new_loop0_exit);
571 }
572
573 } // namespace compiler
574 } // namespace internal
575 } // namespace v8
OLDNEW
« no previous file with comments | « test/cctest/cctest.gyp ('k') | test/mjsunit/compiler/osr-typing-debug-change.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698