OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 #include "test/cctest/cctest.h" | 6 #include "test/cctest/cctest.h" |
7 | 7 |
8 #include "src/compiler/common-operator.h" | 8 #include "src/compiler/common-operator.h" |
9 #include "src/compiler/generic-node-inl.h" | 9 #include "src/compiler/generic-node-inl.h" |
10 #include "src/compiler/generic-node.h" | 10 #include "src/compiler/generic-node.h" |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
139 CheckRPONumbers(order, 2, true); | 139 CheckRPONumbers(order, 2, true); |
140 BasicBlock* loop[] = {schedule.entry(), schedule.exit()}; | 140 BasicBlock* loop[] = {schedule.entry(), schedule.exit()}; |
141 CheckLoopContains(loop, 2); | 141 CheckLoopContains(loop, 2); |
142 } | 142 } |
143 | 143 |
144 | 144 |
145 TEST(RPOEndLoop) { | 145 TEST(RPOEndLoop) { |
146 HandleAndZoneScope scope; | 146 HandleAndZoneScope scope; |
147 Schedule schedule(scope.main_zone()); | 147 Schedule schedule(scope.main_zone()); |
148 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 148 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
149 TestLoop* loop1 = CreateLoop(&schedule, 2); | 149 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2)); |
150 schedule.AddSuccessor(schedule.entry(), loop1->header()); | 150 schedule.AddSuccessor(schedule.entry(), loop1->header()); |
151 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 151 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
152 CheckRPONumbers(order, 3, true); | 152 CheckRPONumbers(order, 3, true); |
153 CheckLoopContains(loop1->nodes, loop1->count); | 153 CheckLoopContains(loop1->nodes, loop1->count); |
154 } | 154 } |
155 | 155 |
156 | 156 |
157 TEST(RPOEndLoopNested) { | 157 TEST(RPOEndLoopNested) { |
158 HandleAndZoneScope scope; | 158 HandleAndZoneScope scope; |
159 Schedule schedule(scope.main_zone()); | 159 Schedule schedule(scope.main_zone()); |
160 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 160 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
161 TestLoop* loop1 = CreateLoop(&schedule, 2); | 161 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2)); |
162 schedule.AddSuccessor(schedule.entry(), loop1->header()); | 162 schedule.AddSuccessor(schedule.entry(), loop1->header()); |
163 schedule.AddSuccessor(loop1->last(), schedule.entry()); | 163 schedule.AddSuccessor(loop1->last(), schedule.entry()); |
164 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 164 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
165 CheckRPONumbers(order, 3, true); | 165 CheckRPONumbers(order, 3, true); |
166 CheckLoopContains(loop1->nodes, loop1->count); | 166 CheckLoopContains(loop1->nodes, loop1->count); |
167 } | 167 } |
168 | 168 |
169 | 169 |
170 TEST(RPODiamond) { | 170 TEST(RPODiamond) { |
171 HandleAndZoneScope scope; | 171 HandleAndZoneScope scope; |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
347 BasicBlock* loop3[] = {D, E}; | 347 BasicBlock* loop3[] = {D, E}; |
348 CheckLoopContains(loop3, 2); | 348 CheckLoopContains(loop3, 2); |
349 } | 349 } |
350 | 350 |
351 | 351 |
352 TEST(RPOLoopFollow1) { | 352 TEST(RPOLoopFollow1) { |
353 HandleAndZoneScope scope; | 353 HandleAndZoneScope scope; |
354 Schedule schedule(scope.main_zone()); | 354 Schedule schedule(scope.main_zone()); |
355 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 355 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
356 | 356 |
357 TestLoop* loop1 = CreateLoop(&schedule, 1); | 357 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1)); |
358 TestLoop* loop2 = CreateLoop(&schedule, 1); | 358 SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1)); |
359 | 359 |
360 BasicBlock* A = schedule.entry(); | 360 BasicBlock* A = schedule.entry(); |
361 BasicBlock* E = schedule.exit(); | 361 BasicBlock* E = schedule.exit(); |
362 | 362 |
363 schedule.AddSuccessor(A, loop1->header()); | 363 schedule.AddSuccessor(A, loop1->header()); |
364 schedule.AddSuccessor(loop1->header(), loop2->header()); | 364 schedule.AddSuccessor(loop1->header(), loop2->header()); |
365 schedule.AddSuccessor(loop2->last(), E); | 365 schedule.AddSuccessor(loop2->last(), E); |
366 | 366 |
367 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 367 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
368 | 368 |
369 CheckLoopContains(loop1->nodes, loop1->count); | 369 CheckLoopContains(loop1->nodes, loop1->count); |
370 | 370 |
371 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); | 371 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); |
372 CheckLoopContains(loop1->nodes, loop1->count); | 372 CheckLoopContains(loop1->nodes, loop1->count); |
373 CheckLoopContains(loop2->nodes, loop2->count); | 373 CheckLoopContains(loop2->nodes, loop2->count); |
374 delete loop1; | |
375 delete loop2; | |
376 } | 374 } |
377 | 375 |
378 | 376 |
379 TEST(RPOLoopFollow2) { | 377 TEST(RPOLoopFollow2) { |
380 HandleAndZoneScope scope; | 378 HandleAndZoneScope scope; |
381 Schedule schedule(scope.main_zone()); | 379 Schedule schedule(scope.main_zone()); |
382 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 380 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
383 | 381 |
384 TestLoop* loop1 = CreateLoop(&schedule, 1); | 382 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1)); |
385 TestLoop* loop2 = CreateLoop(&schedule, 1); | 383 SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1)); |
386 | 384 |
387 BasicBlock* A = schedule.entry(); | 385 BasicBlock* A = schedule.entry(); |
388 BasicBlock* S = schedule.NewBasicBlock(); | 386 BasicBlock* S = schedule.NewBasicBlock(); |
389 BasicBlock* E = schedule.exit(); | 387 BasicBlock* E = schedule.exit(); |
390 | 388 |
391 schedule.AddSuccessor(A, loop1->header()); | 389 schedule.AddSuccessor(A, loop1->header()); |
392 schedule.AddSuccessor(loop1->header(), S); | 390 schedule.AddSuccessor(loop1->header(), S); |
393 schedule.AddSuccessor(S, loop2->header()); | 391 schedule.AddSuccessor(S, loop2->header()); |
394 schedule.AddSuccessor(loop2->last(), E); | 392 schedule.AddSuccessor(loop2->last(), E); |
395 | 393 |
396 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 394 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
397 | 395 |
398 CheckLoopContains(loop1->nodes, loop1->count); | 396 CheckLoopContains(loop1->nodes, loop1->count); |
399 | 397 |
400 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); | 398 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); |
401 CheckLoopContains(loop1->nodes, loop1->count); | 399 CheckLoopContains(loop1->nodes, loop1->count); |
402 CheckLoopContains(loop2->nodes, loop2->count); | 400 CheckLoopContains(loop2->nodes, loop2->count); |
403 delete loop1; | |
404 delete loop2; | |
405 } | 401 } |
406 | 402 |
407 | 403 |
408 TEST(RPOLoopFollowN) { | 404 TEST(RPOLoopFollowN) { |
409 HandleAndZoneScope scope; | 405 HandleAndZoneScope scope; |
410 | 406 |
411 for (int size = 1; size < 5; size++) { | 407 for (int size = 1; size < 5; size++) { |
412 for (int exit = 0; exit < size; exit++) { | 408 for (int exit = 0; exit < size; exit++) { |
413 Schedule schedule(scope.main_zone()); | 409 Schedule schedule(scope.main_zone()); |
414 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 410 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
415 TestLoop* loop1 = CreateLoop(&schedule, size); | 411 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
416 TestLoop* loop2 = CreateLoop(&schedule, size); | 412 SmartPointer<TestLoop> loop2(CreateLoop(&schedule, size)); |
417 BasicBlock* A = schedule.entry(); | 413 BasicBlock* A = schedule.entry(); |
418 BasicBlock* E = schedule.exit(); | 414 BasicBlock* E = schedule.exit(); |
419 | 415 |
420 schedule.AddSuccessor(A, loop1->header()); | 416 schedule.AddSuccessor(A, loop1->header()); |
421 schedule.AddSuccessor(loop1->nodes[exit], loop2->header()); | 417 schedule.AddSuccessor(loop1->nodes[exit], loop2->header()); |
422 schedule.AddSuccessor(loop2->nodes[exit], E); | 418 schedule.AddSuccessor(loop2->nodes[exit], E); |
423 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 419 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
424 CheckLoopContains(loop1->nodes, loop1->count); | 420 CheckLoopContains(loop1->nodes, loop1->count); |
425 | 421 |
426 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); | 422 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); |
427 CheckLoopContains(loop1->nodes, loop1->count); | 423 CheckLoopContains(loop1->nodes, loop1->count); |
428 CheckLoopContains(loop2->nodes, loop2->count); | 424 CheckLoopContains(loop2->nodes, loop2->count); |
429 delete loop1; | |
430 delete loop2; | |
431 } | 425 } |
432 } | 426 } |
433 } | 427 } |
434 | 428 |
435 | 429 |
436 TEST(RPONestedLoopFollow1) { | 430 TEST(RPONestedLoopFollow1) { |
437 HandleAndZoneScope scope; | 431 HandleAndZoneScope scope; |
438 Schedule schedule(scope.main_zone()); | 432 Schedule schedule(scope.main_zone()); |
439 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 433 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
440 | 434 |
441 TestLoop* loop1 = CreateLoop(&schedule, 1); | 435 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1)); |
442 TestLoop* loop2 = CreateLoop(&schedule, 1); | 436 SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1)); |
443 | 437 |
444 BasicBlock* A = schedule.entry(); | 438 BasicBlock* A = schedule.entry(); |
445 BasicBlock* B = schedule.NewBasicBlock(); | 439 BasicBlock* B = schedule.NewBasicBlock(); |
446 BasicBlock* C = schedule.NewBasicBlock(); | 440 BasicBlock* C = schedule.NewBasicBlock(); |
447 BasicBlock* E = schedule.exit(); | 441 BasicBlock* E = schedule.exit(); |
448 | 442 |
449 schedule.AddSuccessor(A, B); | 443 schedule.AddSuccessor(A, B); |
450 schedule.AddSuccessor(B, loop1->header()); | 444 schedule.AddSuccessor(B, loop1->header()); |
451 schedule.AddSuccessor(loop1->header(), loop2->header()); | 445 schedule.AddSuccessor(loop1->header(), loop2->header()); |
452 schedule.AddSuccessor(loop2->last(), C); | 446 schedule.AddSuccessor(loop2->last(), C); |
453 schedule.AddSuccessor(C, E); | 447 schedule.AddSuccessor(C, E); |
454 schedule.AddSuccessor(C, B); | 448 schedule.AddSuccessor(C, B); |
455 | 449 |
456 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 450 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
457 | 451 |
458 CheckLoopContains(loop1->nodes, loop1->count); | 452 CheckLoopContains(loop1->nodes, loop1->count); |
459 | 453 |
460 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); | 454 CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size())); |
461 CheckLoopContains(loop1->nodes, loop1->count); | 455 CheckLoopContains(loop1->nodes, loop1->count); |
462 CheckLoopContains(loop2->nodes, loop2->count); | 456 CheckLoopContains(loop2->nodes, loop2->count); |
463 | 457 |
464 BasicBlock* loop3[] = {B, loop1->nodes[0], loop2->nodes[0], C}; | 458 BasicBlock* loop3[] = {B, loop1->nodes[0], loop2->nodes[0], C}; |
465 CheckLoopContains(loop3, 4); | 459 CheckLoopContains(loop3, 4); |
466 delete loop1; | |
467 delete loop2; | |
468 } | 460 } |
469 | 461 |
470 | 462 |
471 TEST(RPOLoopBackedges1) { | 463 TEST(RPOLoopBackedges1) { |
472 HandleAndZoneScope scope; | 464 HandleAndZoneScope scope; |
473 | 465 |
474 int size = 8; | 466 int size = 8; |
475 for (int i = 0; i < size; i++) { | 467 for (int i = 0; i < size; i++) { |
476 for (int j = 0; j < size; j++) { | 468 for (int j = 0; j < size; j++) { |
477 Schedule schedule(scope.main_zone()); | 469 Schedule schedule(scope.main_zone()); |
478 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 470 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
479 BasicBlock* A = schedule.entry(); | 471 BasicBlock* A = schedule.entry(); |
480 BasicBlock* E = schedule.exit(); | 472 BasicBlock* E = schedule.exit(); |
481 | 473 |
482 TestLoop* loop1 = CreateLoop(&schedule, size); | 474 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
483 schedule.AddSuccessor(A, loop1->header()); | 475 schedule.AddSuccessor(A, loop1->header()); |
484 schedule.AddSuccessor(loop1->last(), E); | 476 schedule.AddSuccessor(loop1->last(), E); |
485 | 477 |
486 schedule.AddSuccessor(loop1->nodes[i], loop1->header()); | 478 schedule.AddSuccessor(loop1->nodes[i], loop1->header()); |
487 schedule.AddSuccessor(loop1->nodes[j], E); | 479 schedule.AddSuccessor(loop1->nodes[j], E); |
488 | 480 |
489 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 481 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
490 CheckRPONumbers(order, schedule.BasicBlockCount(), true); | 482 CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
491 CheckLoopContains(loop1->nodes, loop1->count); | 483 CheckLoopContains(loop1->nodes, loop1->count); |
492 delete loop1; | |
493 } | 484 } |
494 } | 485 } |
495 } | 486 } |
496 | 487 |
497 | 488 |
498 TEST(RPOLoopOutedges1) { | 489 TEST(RPOLoopOutedges1) { |
499 HandleAndZoneScope scope; | 490 HandleAndZoneScope scope; |
500 | 491 |
501 int size = 8; | 492 int size = 8; |
502 for (int i = 0; i < size; i++) { | 493 for (int i = 0; i < size; i++) { |
503 for (int j = 0; j < size; j++) { | 494 for (int j = 0; j < size; j++) { |
504 Schedule schedule(scope.main_zone()); | 495 Schedule schedule(scope.main_zone()); |
505 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 496 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
506 BasicBlock* A = schedule.entry(); | 497 BasicBlock* A = schedule.entry(); |
507 BasicBlock* D = schedule.NewBasicBlock(); | 498 BasicBlock* D = schedule.NewBasicBlock(); |
508 BasicBlock* E = schedule.exit(); | 499 BasicBlock* E = schedule.exit(); |
509 | 500 |
510 TestLoop* loop1 = CreateLoop(&schedule, size); | 501 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
511 schedule.AddSuccessor(A, loop1->header()); | 502 schedule.AddSuccessor(A, loop1->header()); |
512 schedule.AddSuccessor(loop1->last(), E); | 503 schedule.AddSuccessor(loop1->last(), E); |
513 | 504 |
514 schedule.AddSuccessor(loop1->nodes[i], loop1->header()); | 505 schedule.AddSuccessor(loop1->nodes[i], loop1->header()); |
515 schedule.AddSuccessor(loop1->nodes[j], D); | 506 schedule.AddSuccessor(loop1->nodes[j], D); |
516 schedule.AddSuccessor(D, E); | 507 schedule.AddSuccessor(D, E); |
517 | 508 |
518 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 509 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
519 CheckRPONumbers(order, schedule.BasicBlockCount(), true); | 510 CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
520 CheckLoopContains(loop1->nodes, loop1->count); | 511 CheckLoopContains(loop1->nodes, loop1->count); |
521 delete loop1; | |
522 } | 512 } |
523 } | 513 } |
524 } | 514 } |
525 | 515 |
526 | 516 |
527 TEST(RPOLoopOutedges2) { | 517 TEST(RPOLoopOutedges2) { |
528 HandleAndZoneScope scope; | 518 HandleAndZoneScope scope; |
529 | 519 |
530 int size = 8; | 520 int size = 8; |
531 for (int i = 0; i < size; i++) { | 521 for (int i = 0; i < size; i++) { |
532 Schedule schedule(scope.main_zone()); | 522 Schedule schedule(scope.main_zone()); |
533 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 523 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
534 BasicBlock* A = schedule.entry(); | 524 BasicBlock* A = schedule.entry(); |
535 BasicBlock* E = schedule.exit(); | 525 BasicBlock* E = schedule.exit(); |
536 | 526 |
537 TestLoop* loop1 = CreateLoop(&schedule, size); | 527 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
538 schedule.AddSuccessor(A, loop1->header()); | 528 schedule.AddSuccessor(A, loop1->header()); |
539 schedule.AddSuccessor(loop1->last(), E); | 529 schedule.AddSuccessor(loop1->last(), E); |
540 | 530 |
541 for (int j = 0; j < size; j++) { | 531 for (int j = 0; j < size; j++) { |
542 BasicBlock* O = schedule.NewBasicBlock(); | 532 BasicBlock* O = schedule.NewBasicBlock(); |
543 schedule.AddSuccessor(loop1->nodes[j], O); | 533 schedule.AddSuccessor(loop1->nodes[j], O); |
544 schedule.AddSuccessor(O, E); | 534 schedule.AddSuccessor(O, E); |
545 } | 535 } |
546 | 536 |
547 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 537 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
548 CheckRPONumbers(order, schedule.BasicBlockCount(), true); | 538 CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
549 CheckLoopContains(loop1->nodes, loop1->count); | 539 CheckLoopContains(loop1->nodes, loop1->count); |
550 delete loop1; | |
551 } | 540 } |
552 } | 541 } |
553 | 542 |
554 | 543 |
555 TEST(RPOLoopOutloops1) { | 544 TEST(RPOLoopOutloops1) { |
556 HandleAndZoneScope scope; | 545 HandleAndZoneScope scope; |
557 | 546 |
558 int size = 8; | 547 int size = 8; |
559 for (int i = 0; i < size; i++) { | 548 for (int i = 0; i < size; i++) { |
560 Schedule schedule(scope.main_zone()); | 549 Schedule schedule(scope.main_zone()); |
561 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 550 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
562 BasicBlock* A = schedule.entry(); | 551 BasicBlock* A = schedule.entry(); |
563 BasicBlock* E = schedule.exit(); | 552 BasicBlock* E = schedule.exit(); |
564 TestLoop* loop1 = CreateLoop(&schedule, size); | 553 SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
565 schedule.AddSuccessor(A, loop1->header()); | 554 schedule.AddSuccessor(A, loop1->header()); |
566 schedule.AddSuccessor(loop1->last(), E); | 555 schedule.AddSuccessor(loop1->last(), E); |
567 | 556 |
568 TestLoop** loopN = new TestLoop* [size]; | 557 TestLoop** loopN = new TestLoop* [size]; |
569 for (int j = 0; j < size; j++) { | 558 for (int j = 0; j < size; j++) { |
570 loopN[j] = CreateLoop(&schedule, 2); | 559 loopN[j] = CreateLoop(&schedule, 2); |
571 schedule.AddSuccessor(loop1->nodes[j], loopN[j]->header()); | 560 schedule.AddSuccessor(loop1->nodes[j], loopN[j]->header()); |
572 schedule.AddSuccessor(loopN[j]->last(), E); | 561 schedule.AddSuccessor(loopN[j]->last(), E); |
573 } | 562 } |
574 | 563 |
575 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); | 564 BasicBlockVector* order = scheduler.ComputeSpecialRPO(); |
576 CheckRPONumbers(order, schedule.BasicBlockCount(), true); | 565 CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
577 CheckLoopContains(loop1->nodes, loop1->count); | 566 CheckLoopContains(loop1->nodes, loop1->count); |
578 | 567 |
579 for (int j = 0; j < size; j++) { | 568 for (int j = 0; j < size; j++) { |
580 CheckLoopContains(loopN[j]->nodes, loopN[j]->count); | 569 CheckLoopContains(loopN[j]->nodes, loopN[j]->count); |
581 delete loopN[j]; | 570 delete loopN[j]; |
582 } | 571 } |
583 delete[] loopN; | 572 delete[] loopN; |
584 delete loop1; | |
585 } | 573 } |
586 } | 574 } |
587 | 575 |
588 | 576 |
589 TEST(RPOLoopMultibackedge) { | 577 TEST(RPOLoopMultibackedge) { |
590 HandleAndZoneScope scope; | 578 HandleAndZoneScope scope; |
591 Schedule schedule(scope.main_zone()); | 579 Schedule schedule(scope.main_zone()); |
592 Scheduler scheduler(scope.main_zone(), NULL, &schedule); | 580 Scheduler scheduler(scope.main_zone(), NULL, &schedule); |
593 | 581 |
594 BasicBlock* A = schedule.entry(); | 582 BasicBlock* A = schedule.entry(); |
(...skipping 1236 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1831 // The lazy deopt block is deferred. | 1819 // The lazy deopt block is deferred. |
1832 CHECK(deopt_block->deferred_); | 1820 CHECK(deopt_block->deferred_); |
1833 CHECK(!call_block->deferred_); | 1821 CHECK(!call_block->deferred_); |
1834 CHECK(!cont_block->deferred_); | 1822 CHECK(!cont_block->deferred_); |
1835 // The lazy deopt block contains framestate + bailout (and nothing else). | 1823 // The lazy deopt block contains framestate + bailout (and nothing else). |
1836 CHECK_EQ(deoptimization_node, deopt_block->control_input_); | 1824 CHECK_EQ(deoptimization_node, deopt_block->control_input_); |
1837 CHECK_EQ(2, static_cast<int>(deopt_block->nodes_.size())); | 1825 CHECK_EQ(2, static_cast<int>(deopt_block->nodes_.size())); |
1838 CHECK_EQ(lazy_deopt_node, deopt_block->nodes_[0]); | 1826 CHECK_EQ(lazy_deopt_node, deopt_block->nodes_[0]); |
1839 CHECK_EQ(state_node, deopt_block->nodes_[1]); | 1827 CHECK_EQ(state_node, deopt_block->nodes_[1]); |
1840 } | 1828 } |
OLD | NEW |