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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/mjsunit/compiler/inline-exception-1.js

Issue 2245263003: [turbofan] Tests for inlining calls, constructors, property access inside try..catch..finally. (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@p6-base
Patch Set: Wrap long lines. Created 4 years, 3 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 | « no previous file | test/mjsunit/compiler/inline-exception-2.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 // Shard 1.
2
3 // Copyright 2016 the V8 project authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style license that can be
5 // found in the LICENSE file.
6
7 // Flags: --allow-natives-syntax --turbo --no-always-opt
8
9 // This test file was generated by tools/gen-inlining-tests.py .
10
11 // Global variables
12 var deopt = undefined; // either true or false
13 var counter = 0;
14
15 function resetState() {
16 counter = 0;
17 }
18
19 function warmUp(f) {
20 try {
21 f();
22 } catch (ex) {
23 // ok
24 }
25 try {
26 f();
27 } catch (ex) {
28 // ok
29 }
30 }
31
32 function resetOptAndAssertResultEquals(expected, f) {
33 warmUp(f);
34 resetState();
35 // %DebugPrint(f);
36 eval("'dont optimize this function itself please, but do optimize f'");
37 %OptimizeFunctionOnNextCall(f);
38 assertEquals(expected, f());
39 }
40
41 function resetOptAndAssertThrowsWith(expected, f) {
42 warmUp(f);
43 resetState();
44 // %DebugPrint(f);
45 eval("'dont optimize this function itself please, but do optimize f'");
46 %OptimizeFunctionOnNextCall(f);
47 try {
48 var result = f();
49 fail("resetOptAndAssertThrowsWith",
50 "exception: " + expected,
51 "result: " + result);
52 } catch (ex) {
53 assertEquals(expected, ex);
54 }
55 }
56
57 function increaseAndReturn15() {
58 if (deopt) %DeoptimizeFunction(f);
59 counter++;
60 return 15;
61 }
62
63 function increaseAndThrow42() {
64 if (deopt) %DeoptimizeFunction(f);
65 counter++;
66 throw 42;
67 }
68
69 function returnOrThrow(doReturn) {
70 if (doReturn) {
71 return increaseAndReturn15();
72 } else {
73 return increaseAndThrow42();
74 }
75 }
76
77 // When passed either {increaseAndReturn15} or {increaseAndThrow42}, it acts
78 // as the other one.
79 function invertFunctionCall(f) {
80 var result;
81 try {
82 result = f();
83 } catch (ex) {
84 return ex - 27;
85 }
86 throw result + 27;
87 }
88
89 function increaseAndStore15Constructor() {
90 if (deopt) %DeoptimizeFunction(f);
91 ++counter;
92 this.x = 15;
93 }
94
95 function increaseAndThrow42Constructor() {
96 if (deopt) %DeoptimizeFunction(f);
97 ++counter;
98 this.x = 42;
99 throw this.x;
100 }
101
102 var magic = {};
103 Object.defineProperty(magic, 'prop', {
104 get: function () {
105 if (deopt) %DeoptimizeFunction(f);
106 return 15 + 0 * ++counter;
107 },
108
109 set: function(x) {
110 // argument should be 37
111 if (deopt) %DeoptimizeFunction(f);
112 counter -= 36 - x; // increments counter
113 throw 42;
114 }
115 })
116
117 // Generate type feedback.
118
119 assertEquals(15, (new increaseAndStore15Constructor()).x);
120 assertThrowsEquals(function() {
121 return (new increaseAndThrow42Constructor()).x;
122 },
123 42);
124
125 function runThisShard() {
126
127 // Variant flags: [tryReturns, doFinally]
128
129 f = function f______r______f____ () {
130 var local = 3;
131 deopt = false;
132 try {
133 counter++;
134 return increaseAndReturn15();
135 counter++;
136 } finally {
137 counter++;
138 local += 2;
139 counter++;
140 }
141 counter++;
142 }
143 resetOptAndAssertResultEquals(15, f);
144 assertEquals(4, counter);
145
146 // Variant flags: [tryReturns, doFinally, finallyThrows]
147
148 f = function f______r______f_t__ () {
149 var local = 3;
150 deopt = false;
151 try {
152 counter++;
153 return increaseAndReturn15();
154 counter++;
155 } finally {
156 counter++;
157 throw 25;
158 counter++;
159 }
160 counter++;
161 }
162 resetOptAndAssertThrowsWith(25, f);
163 assertEquals(3, counter);
164
165 // Variant flags: [tryReturns, doFinally, finallyReturns]
166
167 f = function f______r______fr___ () {
168 var local = 3;
169 deopt = false;
170 try {
171 counter++;
172 return increaseAndReturn15();
173 counter++;
174 } finally {
175 counter++;
176 return 3 + local;
177 counter++;
178 }
179 counter++;
180 }
181 resetOptAndAssertResultEquals(6, f);
182 assertEquals(3, counter);
183
184 // Variant flags: [tryReturns, doCatch]
185
186 f = function f______r__c________ () {
187 var local = 3;
188 deopt = false;
189 try {
190 counter++;
191 return increaseAndReturn15();
192 counter++;
193 } catch (ex) {
194 counter++;
195 counter++;
196 }
197 counter++;
198 }
199 resetOptAndAssertResultEquals(15, f);
200 assertEquals(2, counter);
201
202 // Variant flags: [tryReturns, doCatch, deopt]
203
204 f = function f______r__c_______d () {
205 var local = 3;
206 deopt = true;
207 try {
208 counter++;
209 return increaseAndReturn15();
210 counter++;
211 } catch (ex) {
212 counter++;
213 counter++;
214 }
215 counter++;
216 }
217 resetOptAndAssertResultEquals(15, f);
218 assertEquals(2, counter);
219
220 // Variant flags: [tryReturns, doCatch, doFinally]
221
222 f = function f______r__c___f____ () {
223 var local = 3;
224 deopt = false;
225 try {
226 counter++;
227 return increaseAndReturn15();
228 counter++;
229 } catch (ex) {
230 counter++;
231 counter++;
232 } finally {
233 counter++;
234 local += 2;
235 counter++;
236 }
237 counter++;
238 }
239 resetOptAndAssertResultEquals(15, f);
240 assertEquals(4, counter);
241
242 // Variant flags: [tryReturns, doCatch, doFinally, finallyThrows]
243
244 f = function f______r__c___f_t__ () {
245 var local = 3;
246 deopt = false;
247 try {
248 counter++;
249 return increaseAndReturn15();
250 counter++;
251 } catch (ex) {
252 counter++;
253 counter++;
254 } finally {
255 counter++;
256 throw 25;
257 counter++;
258 }
259 counter++;
260 }
261 resetOptAndAssertThrowsWith(25, f);
262 assertEquals(3, counter);
263
264 // Variant flags: [tryReturns, doCatch, doFinally, finallyReturns]
265
266 f = function f______r__c___fr___ () {
267 var local = 3;
268 deopt = false;
269 try {
270 counter++;
271 return increaseAndReturn15();
272 counter++;
273 } catch (ex) {
274 counter++;
275 counter++;
276 } finally {
277 counter++;
278 return 3 + local;
279 counter++;
280 }
281 counter++;
282 }
283 resetOptAndAssertResultEquals(6, f);
284 assertEquals(3, counter);
285
286 // Variant flags: [tryReturns, doCatch, catchThrows]
287
288 f = function f______r__c__t_____ () {
289 var local = 3;
290 deopt = false;
291 try {
292 counter++;
293 return increaseAndReturn15();
294 counter++;
295 } catch (ex) {
296 counter++;
297 throw 2 + ex;
298 counter++;
299 }
300 counter++;
301 }
302 resetOptAndAssertResultEquals(15, f);
303 assertEquals(2, counter);
304
305 // Variant flags: [tryReturns, doCatch, catchThrows, deopt]
306
307 f = function f______r__c__t____d () {
308 var local = 3;
309 deopt = true;
310 try {
311 counter++;
312 return increaseAndReturn15();
313 counter++;
314 } catch (ex) {
315 counter++;
316 throw 2 + ex;
317 counter++;
318 }
319 counter++;
320 }
321 resetOptAndAssertResultEquals(15, f);
322 assertEquals(2, counter);
323
324 // Variant flags: [tryReturns, doCatch, catchThrows, doFinally]
325
326 f = function f______r__c__tf____ () {
327 var local = 3;
328 deopt = false;
329 try {
330 counter++;
331 return increaseAndReturn15();
332 counter++;
333 } catch (ex) {
334 counter++;
335 throw 2 + ex;
336 counter++;
337 } finally {
338 counter++;
339 local += 2;
340 counter++;
341 }
342 counter++;
343 }
344 resetOptAndAssertResultEquals(15, f);
345 assertEquals(4, counter);
346
347 // Variant flags: [tryReturns, doCatch, catchThrows, doFinally,
348 // finallyThrows]
349
350 f = function f______r__c__tf_t__ () {
351 var local = 3;
352 deopt = false;
353 try {
354 counter++;
355 return increaseAndReturn15();
356 counter++;
357 } catch (ex) {
358 counter++;
359 throw 2 + ex;
360 counter++;
361 } finally {
362 counter++;
363 throw 25;
364 counter++;
365 }
366 counter++;
367 }
368 resetOptAndAssertThrowsWith(25, f);
369 assertEquals(3, counter);
370
371 // Variant flags: [tryReturns, doCatch, catchThrows, doFinally,
372 // finallyReturns]
373
374 f = function f______r__c__tfr___ () {
375 var local = 3;
376 deopt = false;
377 try {
378 counter++;
379 return increaseAndReturn15();
380 counter++;
381 } catch (ex) {
382 counter++;
383 throw 2 + ex;
384 counter++;
385 } finally {
386 counter++;
387 return 3 + local;
388 counter++;
389 }
390 counter++;
391 }
392 resetOptAndAssertResultEquals(6, f);
393 assertEquals(3, counter);
394
395 // Variant flags: [tryReturns, doCatch, catchReturns]
396
397 f = function f______r__cr_______ () {
398 var local = 3;
399 deopt = false;
400 try {
401 counter++;
402 return increaseAndReturn15();
403 counter++;
404 } catch (ex) {
405 counter++;
406 return 2 + ex;
407 counter++;
408 }
409 counter++;
410 }
411 resetOptAndAssertResultEquals(15, f);
412 assertEquals(2, counter);
413
414 // Variant flags: [tryReturns, doCatch, catchReturns, deopt]
415
416 f = function f______r__cr______d () {
417 var local = 3;
418 deopt = true;
419 try {
420 counter++;
421 return increaseAndReturn15();
422 counter++;
423 } catch (ex) {
424 counter++;
425 return 2 + ex;
426 counter++;
427 }
428 counter++;
429 }
430 resetOptAndAssertResultEquals(15, f);
431 assertEquals(2, counter);
432
433 // Variant flags: [tryReturns, doCatch, catchReturns, doFinally]
434
435 f = function f______r__cr__f____ () {
436 var local = 3;
437 deopt = false;
438 try {
439 counter++;
440 return increaseAndReturn15();
441 counter++;
442 } catch (ex) {
443 counter++;
444 return 2 + ex;
445 counter++;
446 } finally {
447 counter++;
448 local += 2;
449 counter++;
450 }
451 counter++;
452 }
453 resetOptAndAssertResultEquals(15, f);
454 assertEquals(4, counter);
455
456 // Variant flags: [tryReturns, doCatch, catchReturns, doFinally,
457 // finallyThrows]
458
459 f = function f______r__cr__f_t__ () {
460 var local = 3;
461 deopt = false;
462 try {
463 counter++;
464 return increaseAndReturn15();
465 counter++;
466 } catch (ex) {
467 counter++;
468 return 2 + ex;
469 counter++;
470 } finally {
471 counter++;
472 throw 25;
473 counter++;
474 }
475 counter++;
476 }
477 resetOptAndAssertThrowsWith(25, f);
478 assertEquals(3, counter);
479
480 // Variant flags: [tryReturns, doCatch, catchReturns, doFinally,
481 // finallyReturns]
482
483 f = function f______r__cr__fr___ () {
484 var local = 3;
485 deopt = false;
486 try {
487 counter++;
488 return increaseAndReturn15();
489 counter++;
490 } catch (ex) {
491 counter++;
492 return 2 + ex;
493 counter++;
494 } finally {
495 counter++;
496 return 3 + local;
497 counter++;
498 }
499 counter++;
500 }
501 resetOptAndAssertResultEquals(6, f);
502 assertEquals(3, counter);
503
504 // Variant flags: [tryThrows, doFinally]
505
506 f = function f_____t_______f____ () {
507 var local = 3;
508 deopt = false;
509 try {
510 counter++;
511 return increaseAndThrow42();
512 counter++;
513 } finally {
514 counter++;
515 local += 2;
516 counter++;
517 }
518 counter++;
519 }
520 resetOptAndAssertThrowsWith(42, f);
521 assertEquals(4, counter);
522
523 // Variant flags: [tryThrows, doFinally, finallyThrows]
524
525 f = function f_____t_______f_t__ () {
526 var local = 3;
527 deopt = false;
528 try {
529 counter++;
530 return increaseAndThrow42();
531 counter++;
532 } finally {
533 counter++;
534 throw 25;
535 counter++;
536 }
537 counter++;
538 }
539 resetOptAndAssertThrowsWith(25, f);
540 assertEquals(3, counter);
541
542 // Variant flags: [tryThrows, doFinally, finallyReturns]
543
544 f = function f_____t_______fr___ () {
545 var local = 3;
546 deopt = false;
547 try {
548 counter++;
549 return increaseAndThrow42();
550 counter++;
551 } finally {
552 counter++;
553 return 3 + local;
554 counter++;
555 }
556 counter++;
557 }
558 resetOptAndAssertResultEquals(6, f);
559 assertEquals(3, counter);
560
561 // Variant flags: [tryThrows, doCatch]
562
563 f = function f_____t___c________ () {
564 var local = 3;
565 deopt = false;
566 try {
567 counter++;
568 return increaseAndThrow42();
569 counter++;
570 } catch (ex) {
571 counter++;
572 counter++;
573 }
574 counter++;
575 }
576 resetOptAndAssertResultEquals(undefined, f);
577 assertEquals(5, counter);
578
579 // Variant flags: [tryThrows, doCatch, deopt]
580
581 f = function f_____t___c_______d () {
582 var local = 3;
583 deopt = true;
584 try {
585 counter++;
586 return increaseAndThrow42();
587 counter++;
588 } catch (ex) {
589 counter++;
590 counter++;
591 }
592 counter++;
593 }
594 resetOptAndAssertResultEquals(undefined, f);
595 assertEquals(5, counter);
596
597 // Variant flags: [tryThrows, doCatch, doFinally]
598
599 f = function f_____t___c___f____ () {
600 var local = 3;
601 deopt = false;
602 try {
603 counter++;
604 return increaseAndThrow42();
605 counter++;
606 } catch (ex) {
607 counter++;
608 counter++;
609 } finally {
610 counter++;
611 local += 2;
612 counter++;
613 }
614 counter++;
615 }
616 resetOptAndAssertResultEquals(undefined, f);
617 assertEquals(7, counter);
618
619 // Variant flags: [tryThrows, doCatch, doFinally, finallyThrows]
620
621 f = function f_____t___c___f_t__ () {
622 var local = 3;
623 deopt = false;
624 try {
625 counter++;
626 return increaseAndThrow42();
627 counter++;
628 } catch (ex) {
629 counter++;
630 counter++;
631 } finally {
632 counter++;
633 throw 25;
634 counter++;
635 }
636 counter++;
637 }
638 resetOptAndAssertThrowsWith(25, f);
639 assertEquals(5, counter);
640
641 // Variant flags: [tryThrows, doCatch, doFinally, finallyReturns]
642
643 f = function f_____t___c___fr___ () {
644 var local = 3;
645 deopt = false;
646 try {
647 counter++;
648 return increaseAndThrow42();
649 counter++;
650 } catch (ex) {
651 counter++;
652 counter++;
653 } finally {
654 counter++;
655 return 3 + local;
656 counter++;
657 }
658 counter++;
659 }
660 resetOptAndAssertResultEquals(6, f);
661 assertEquals(5, counter);
662
663 // Variant flags: [tryThrows, doCatch, catchThrows]
664
665 f = function f_____t___c__t_____ () {
666 var local = 3;
667 deopt = false;
668 try {
669 counter++;
670 return increaseAndThrow42();
671 counter++;
672 } catch (ex) {
673 counter++;
674 throw 2 + ex;
675 counter++;
676 }
677 counter++;
678 }
679 resetOptAndAssertThrowsWith(44, f);
680 assertEquals(3, counter);
681
682 // Variant flags: [tryThrows, doCatch, catchThrows, deopt]
683
684 f = function f_____t___c__t____d () {
685 var local = 3;
686 deopt = true;
687 try {
688 counter++;
689 return increaseAndThrow42();
690 counter++;
691 } catch (ex) {
692 counter++;
693 throw 2 + ex;
694 counter++;
695 }
696 counter++;
697 }
698 resetOptAndAssertThrowsWith(44, f);
699 assertEquals(3, counter);
700
701 // Variant flags: [tryThrows, doCatch, catchThrows, doFinally]
702
703 f = function f_____t___c__tf____ () {
704 var local = 3;
705 deopt = false;
706 try {
707 counter++;
708 return increaseAndThrow42();
709 counter++;
710 } catch (ex) {
711 counter++;
712 throw 2 + ex;
713 counter++;
714 } finally {
715 counter++;
716 local += 2;
717 counter++;
718 }
719 counter++;
720 }
721 resetOptAndAssertThrowsWith(44, f);
722 assertEquals(5, counter);
723
724 // Variant flags: [tryThrows, doCatch, catchThrows, doFinally,
725 // finallyThrows]
726
727 f = function f_____t___c__tf_t__ () {
728 var local = 3;
729 deopt = false;
730 try {
731 counter++;
732 return increaseAndThrow42();
733 counter++;
734 } catch (ex) {
735 counter++;
736 throw 2 + ex;
737 counter++;
738 } finally {
739 counter++;
740 throw 25;
741 counter++;
742 }
743 counter++;
744 }
745 resetOptAndAssertThrowsWith(25, f);
746 assertEquals(4, counter);
747
748 // Variant flags: [tryThrows, doCatch, catchThrows, doFinally,
749 // finallyReturns]
750
751 f = function f_____t___c__tfr___ () {
752 var local = 3;
753 deopt = false;
754 try {
755 counter++;
756 return increaseAndThrow42();
757 counter++;
758 } catch (ex) {
759 counter++;
760 throw 2 + ex;
761 counter++;
762 } finally {
763 counter++;
764 return 3 + local;
765 counter++;
766 }
767 counter++;
768 }
769 resetOptAndAssertResultEquals(6, f);
770 assertEquals(4, counter);
771
772 // Variant flags: [tryThrows, doCatch, catchReturns]
773
774 f = function f_____t___cr_______ () {
775 var local = 3;
776 deopt = false;
777 try {
778 counter++;
779 return increaseAndThrow42();
780 counter++;
781 } catch (ex) {
782 counter++;
783 return 2 + ex;
784 counter++;
785 }
786 counter++;
787 }
788 resetOptAndAssertResultEquals(44, f);
789 assertEquals(3, counter);
790
791 // Variant flags: [tryThrows, doCatch, catchReturns, deopt]
792
793 f = function f_____t___cr______d () {
794 var local = 3;
795 deopt = true;
796 try {
797 counter++;
798 return increaseAndThrow42();
799 counter++;
800 } catch (ex) {
801 counter++;
802 return 2 + ex;
803 counter++;
804 }
805 counter++;
806 }
807 resetOptAndAssertResultEquals(44, f);
808 assertEquals(3, counter);
809
810 // Variant flags: [tryThrows, doCatch, catchReturns, doFinally]
811
812 f = function f_____t___cr__f____ () {
813 var local = 3;
814 deopt = false;
815 try {
816 counter++;
817 return increaseAndThrow42();
818 counter++;
819 } catch (ex) {
820 counter++;
821 return 2 + ex;
822 counter++;
823 } finally {
824 counter++;
825 local += 2;
826 counter++;
827 }
828 counter++;
829 }
830 resetOptAndAssertResultEquals(44, f);
831 assertEquals(5, counter);
832
833 // Variant flags: [tryThrows, doCatch, catchReturns, doFinally,
834 // finallyThrows]
835
836 f = function f_____t___cr__f_t__ () {
837 var local = 3;
838 deopt = false;
839 try {
840 counter++;
841 return increaseAndThrow42();
842 counter++;
843 } catch (ex) {
844 counter++;
845 return 2 + ex;
846 counter++;
847 } finally {
848 counter++;
849 throw 25;
850 counter++;
851 }
852 counter++;
853 }
854 resetOptAndAssertThrowsWith(25, f);
855 assertEquals(4, counter);
856
857 // Variant flags: [tryThrows, doCatch, catchReturns, doFinally,
858 // finallyReturns]
859
860 f = function f_____t___cr__fr___ () {
861 var local = 3;
862 deopt = false;
863 try {
864 counter++;
865 return increaseAndThrow42();
866 counter++;
867 } catch (ex) {
868 counter++;
869 return 2 + ex;
870 counter++;
871 } finally {
872 counter++;
873 return 3 + local;
874 counter++;
875 }
876 counter++;
877 }
878 resetOptAndAssertResultEquals(6, f);
879 assertEquals(4, counter);
880
881 // Variant flags: [tryThrows, tryReturns, doFinally]
882
883 f = function f_____tr______f____ () {
884 var local = 3;
885 deopt = false;
886 try {
887 counter++;
888 return increaseAndThrow42();
889 return increaseAndReturn15();
890 counter++;
891 } finally {
892 counter++;
893 local += 2;
894 counter++;
895 }
896 counter++;
897 }
898 resetOptAndAssertThrowsWith(42, f);
899 assertEquals(4, counter);
900
901 // Variant flags: [tryThrows, tryReturns, doFinally, finallyThrows]
902
903 f = function f_____tr______f_t__ () {
904 var local = 3;
905 deopt = false;
906 try {
907 counter++;
908 return increaseAndThrow42();
909 return increaseAndReturn15();
910 counter++;
911 } finally {
912 counter++;
913 throw 25;
914 counter++;
915 }
916 counter++;
917 }
918 resetOptAndAssertThrowsWith(25, f);
919 assertEquals(3, counter);
920
921 // Variant flags: [tryThrows, tryReturns, doFinally, finallyReturns]
922
923 f = function f_____tr______fr___ () {
924 var local = 3;
925 deopt = false;
926 try {
927 counter++;
928 return increaseAndThrow42();
929 return increaseAndReturn15();
930 counter++;
931 } finally {
932 counter++;
933 return 3 + local;
934 counter++;
935 }
936 counter++;
937 }
938 resetOptAndAssertResultEquals(6, f);
939 assertEquals(3, counter);
940
941 // Variant flags: [tryThrows, tryReturns, doCatch]
942
943 f = function f_____tr__c________ () {
944 var local = 3;
945 deopt = false;
946 try {
947 counter++;
948 return increaseAndThrow42();
949 return increaseAndReturn15();
950 counter++;
951 } catch (ex) {
952 counter++;
953 counter++;
954 }
955 counter++;
956 }
957 resetOptAndAssertResultEquals(undefined, f);
958 assertEquals(5, counter);
959
960 // Variant flags: [tryThrows, tryReturns, doCatch, doFinally]
961
962 f = function f_____tr__c___f____ () {
963 var local = 3;
964 deopt = false;
965 try {
966 counter++;
967 return increaseAndThrow42();
968 return increaseAndReturn15();
969 counter++;
970 } catch (ex) {
971 counter++;
972 counter++;
973 } finally {
974 counter++;
975 local += 2;
976 counter++;
977 }
978 counter++;
979 }
980 resetOptAndAssertResultEquals(undefined, f);
981 assertEquals(7, counter);
982
983 // Variant flags: [tryThrows, tryReturns, doCatch, doFinally,
984 // finallyThrows]
985
986 f = function f_____tr__c___f_t__ () {
987 var local = 3;
988 deopt = false;
989 try {
990 counter++;
991 return increaseAndThrow42();
992 return increaseAndReturn15();
993 counter++;
994 } catch (ex) {
995 counter++;
996 counter++;
997 } finally {
998 counter++;
999 throw 25;
1000 counter++;
1001 }
1002 counter++;
1003 }
1004 resetOptAndAssertThrowsWith(25, f);
1005 assertEquals(5, counter);
1006
1007 // Variant flags: [tryThrows, tryReturns, doCatch, doFinally,
1008 // finallyReturns]
1009
1010 f = function f_____tr__c___fr___ () {
1011 var local = 3;
1012 deopt = false;
1013 try {
1014 counter++;
1015 return increaseAndThrow42();
1016 return increaseAndReturn15();
1017 counter++;
1018 } catch (ex) {
1019 counter++;
1020 counter++;
1021 } finally {
1022 counter++;
1023 return 3 + local;
1024 counter++;
1025 }
1026 counter++;
1027 }
1028 resetOptAndAssertResultEquals(6, f);
1029 assertEquals(5, counter);
1030
1031 // Variant flags: [tryThrows, tryReturns, doCatch, catchThrows]
1032
1033 f = function f_____tr__c__t_____ () {
1034 var local = 3;
1035 deopt = false;
1036 try {
1037 counter++;
1038 return increaseAndThrow42();
1039 return increaseAndReturn15();
1040 counter++;
1041 } catch (ex) {
1042 counter++;
1043 throw 2 + ex;
1044 counter++;
1045 }
1046 counter++;
1047 }
1048 resetOptAndAssertThrowsWith(44, f);
1049 assertEquals(3, counter);
1050
1051 // Variant flags: [tryThrows, tryReturns, doCatch, catchThrows,
1052 // doFinally]
1053
1054 f = function f_____tr__c__tf____ () {
1055 var local = 3;
1056 deopt = false;
1057 try {
1058 counter++;
1059 return increaseAndThrow42();
1060 return increaseAndReturn15();
1061 counter++;
1062 } catch (ex) {
1063 counter++;
1064 throw 2 + ex;
1065 counter++;
1066 } finally {
1067 counter++;
1068 local += 2;
1069 counter++;
1070 }
1071 counter++;
1072 }
1073 resetOptAndAssertThrowsWith(44, f);
1074 assertEquals(5, counter);
1075
1076 // Variant flags: [tryThrows, tryReturns, doCatch, catchThrows,
1077 // doFinally, finallyThrows]
1078
1079 f = function f_____tr__c__tf_t__ () {
1080 var local = 3;
1081 deopt = false;
1082 try {
1083 counter++;
1084 return increaseAndThrow42();
1085 return increaseAndReturn15();
1086 counter++;
1087 } catch (ex) {
1088 counter++;
1089 throw 2 + ex;
1090 counter++;
1091 } finally {
1092 counter++;
1093 throw 25;
1094 counter++;
1095 }
1096 counter++;
1097 }
1098 resetOptAndAssertThrowsWith(25, f);
1099 assertEquals(4, counter);
1100
1101 // Variant flags: [tryThrows, tryReturns, doCatch, catchThrows,
1102 // doFinally, finallyReturns]
1103
1104 f = function f_____tr__c__tfr___ () {
1105 var local = 3;
1106 deopt = false;
1107 try {
1108 counter++;
1109 return increaseAndThrow42();
1110 return increaseAndReturn15();
1111 counter++;
1112 } catch (ex) {
1113 counter++;
1114 throw 2 + ex;
1115 counter++;
1116 } finally {
1117 counter++;
1118 return 3 + local;
1119 counter++;
1120 }
1121 counter++;
1122 }
1123 resetOptAndAssertResultEquals(6, f);
1124 assertEquals(4, counter);
1125
1126 // Variant flags: [tryThrows, tryReturns, doCatch, catchReturns]
1127
1128 f = function f_____tr__cr_______ () {
1129 var local = 3;
1130 deopt = false;
1131 try {
1132 counter++;
1133 return increaseAndThrow42();
1134 return increaseAndReturn15();
1135 counter++;
1136 } catch (ex) {
1137 counter++;
1138 return 2 + ex;
1139 counter++;
1140 }
1141 counter++;
1142 }
1143 resetOptAndAssertResultEquals(44, f);
1144 assertEquals(3, counter);
1145
1146 // Variant flags: [tryThrows, tryReturns, doCatch, catchReturns,
1147 // doFinally]
1148
1149 f = function f_____tr__cr__f____ () {
1150 var local = 3;
1151 deopt = false;
1152 try {
1153 counter++;
1154 return increaseAndThrow42();
1155 return increaseAndReturn15();
1156 counter++;
1157 } catch (ex) {
1158 counter++;
1159 return 2 + ex;
1160 counter++;
1161 } finally {
1162 counter++;
1163 local += 2;
1164 counter++;
1165 }
1166 counter++;
1167 }
1168 resetOptAndAssertResultEquals(44, f);
1169 assertEquals(5, counter);
1170
1171 // Variant flags: [tryThrows, tryReturns, doCatch, catchReturns,
1172 // doFinally, finallyThrows]
1173
1174 f = function f_____tr__cr__f_t__ () {
1175 var local = 3;
1176 deopt = false;
1177 try {
1178 counter++;
1179 return increaseAndThrow42();
1180 return increaseAndReturn15();
1181 counter++;
1182 } catch (ex) {
1183 counter++;
1184 return 2 + ex;
1185 counter++;
1186 } finally {
1187 counter++;
1188 throw 25;
1189 counter++;
1190 }
1191 counter++;
1192 }
1193 resetOptAndAssertThrowsWith(25, f);
1194 assertEquals(4, counter);
1195
1196 // Variant flags: [tryThrows, tryReturns, doCatch, catchReturns,
1197 // doFinally, finallyReturns]
1198
1199 f = function f_____tr__cr__fr___ () {
1200 var local = 3;
1201 deopt = false;
1202 try {
1203 counter++;
1204 return increaseAndThrow42();
1205 return increaseAndReturn15();
1206 counter++;
1207 } catch (ex) {
1208 counter++;
1209 return 2 + ex;
1210 counter++;
1211 } finally {
1212 counter++;
1213 return 3 + local;
1214 counter++;
1215 }
1216 counter++;
1217 }
1218 resetOptAndAssertResultEquals(6, f);
1219 assertEquals(4, counter);
1220
1221 // Variant flags: [tryThrows, tryReturns, tryFirstReturns,
1222 // doFinally]
1223
1224 f = function f_____trf_____f____ () {
1225 var local = 3;
1226 deopt = false;
1227 try {
1228 counter++;
1229 return increaseAndReturn15();
1230 return increaseAndThrow42();
1231 counter++;
1232 } finally {
1233 counter++;
1234 local += 2;
1235 counter++;
1236 }
1237 counter++;
1238 }
1239 resetOptAndAssertResultEquals(15, f);
1240 assertEquals(4, counter);
1241
1242 // Variant flags: [tryThrows, tryReturns, tryFirstReturns,
1243 // doFinally, finallyThrows]
1244
1245 f = function f_____trf_____f_t__ () {
1246 var local = 3;
1247 deopt = false;
1248 try {
1249 counter++;
1250 return increaseAndReturn15();
1251 return increaseAndThrow42();
1252 counter++;
1253 } finally {
1254 counter++;
1255 throw 25;
1256 counter++;
1257 }
1258 counter++;
1259 }
1260 resetOptAndAssertThrowsWith(25, f);
1261 assertEquals(3, counter);
1262
1263 // Variant flags: [tryThrows, tryReturns, tryFirstReturns,
1264 // doFinally, finallyReturns]
1265
1266 f = function f_____trf_____fr___ () {
1267 var local = 3;
1268 deopt = false;
1269 try {
1270 counter++;
1271 return increaseAndReturn15();
1272 return increaseAndThrow42();
1273 counter++;
1274 } finally {
1275 counter++;
1276 return 3 + local;
1277 counter++;
1278 }
1279 counter++;
1280 }
1281 resetOptAndAssertResultEquals(6, f);
1282 assertEquals(3, counter);
1283
1284 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch]
1285
1286 f = function f_____trf_c________ () {
1287 var local = 3;
1288 deopt = false;
1289 try {
1290 counter++;
1291 return increaseAndReturn15();
1292 return increaseAndThrow42();
1293 counter++;
1294 } catch (ex) {
1295 counter++;
1296 counter++;
1297 }
1298 counter++;
1299 }
1300 resetOptAndAssertResultEquals(15, f);
1301 assertEquals(2, counter);
1302
1303 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1304 // doFinally]
1305
1306 f = function f_____trf_c___f____ () {
1307 var local = 3;
1308 deopt = false;
1309 try {
1310 counter++;
1311 return increaseAndReturn15();
1312 return increaseAndThrow42();
1313 counter++;
1314 } catch (ex) {
1315 counter++;
1316 counter++;
1317 } finally {
1318 counter++;
1319 local += 2;
1320 counter++;
1321 }
1322 counter++;
1323 }
1324 resetOptAndAssertResultEquals(15, f);
1325 assertEquals(4, counter);
1326
1327 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1328 // doFinally, finallyThrows]
1329
1330 f = function f_____trf_c___f_t__ () {
1331 var local = 3;
1332 deopt = false;
1333 try {
1334 counter++;
1335 return increaseAndReturn15();
1336 return increaseAndThrow42();
1337 counter++;
1338 } catch (ex) {
1339 counter++;
1340 counter++;
1341 } finally {
1342 counter++;
1343 throw 25;
1344 counter++;
1345 }
1346 counter++;
1347 }
1348 resetOptAndAssertThrowsWith(25, f);
1349 assertEquals(3, counter);
1350
1351 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1352 // doFinally, finallyReturns]
1353
1354 f = function f_____trf_c___fr___ () {
1355 var local = 3;
1356 deopt = false;
1357 try {
1358 counter++;
1359 return increaseAndReturn15();
1360 return increaseAndThrow42();
1361 counter++;
1362 } catch (ex) {
1363 counter++;
1364 counter++;
1365 } finally {
1366 counter++;
1367 return 3 + local;
1368 counter++;
1369 }
1370 counter++;
1371 }
1372 resetOptAndAssertResultEquals(6, f);
1373 assertEquals(3, counter);
1374
1375 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1376 // catchThrows]
1377
1378 f = function f_____trf_c__t_____ () {
1379 var local = 3;
1380 deopt = false;
1381 try {
1382 counter++;
1383 return increaseAndReturn15();
1384 return increaseAndThrow42();
1385 counter++;
1386 } catch (ex) {
1387 counter++;
1388 throw 2 + ex;
1389 counter++;
1390 }
1391 counter++;
1392 }
1393 resetOptAndAssertResultEquals(15, f);
1394 assertEquals(2, counter);
1395
1396 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1397 // catchThrows, doFinally]
1398
1399 f = function f_____trf_c__tf____ () {
1400 var local = 3;
1401 deopt = false;
1402 try {
1403 counter++;
1404 return increaseAndReturn15();
1405 return increaseAndThrow42();
1406 counter++;
1407 } catch (ex) {
1408 counter++;
1409 throw 2 + ex;
1410 counter++;
1411 } finally {
1412 counter++;
1413 local += 2;
1414 counter++;
1415 }
1416 counter++;
1417 }
1418 resetOptAndAssertResultEquals(15, f);
1419 assertEquals(4, counter);
1420
1421 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1422 // catchThrows, doFinally, finallyThrows]
1423
1424 f = function f_____trf_c__tf_t__ () {
1425 var local = 3;
1426 deopt = false;
1427 try {
1428 counter++;
1429 return increaseAndReturn15();
1430 return increaseAndThrow42();
1431 counter++;
1432 } catch (ex) {
1433 counter++;
1434 throw 2 + ex;
1435 counter++;
1436 } finally {
1437 counter++;
1438 throw 25;
1439 counter++;
1440 }
1441 counter++;
1442 }
1443 resetOptAndAssertThrowsWith(25, f);
1444 assertEquals(3, counter);
1445
1446 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1447 // catchThrows, doFinally, finallyReturns]
1448
1449 f = function f_____trf_c__tfr___ () {
1450 var local = 3;
1451 deopt = false;
1452 try {
1453 counter++;
1454 return increaseAndReturn15();
1455 return increaseAndThrow42();
1456 counter++;
1457 } catch (ex) {
1458 counter++;
1459 throw 2 + ex;
1460 counter++;
1461 } finally {
1462 counter++;
1463 return 3 + local;
1464 counter++;
1465 }
1466 counter++;
1467 }
1468 resetOptAndAssertResultEquals(6, f);
1469 assertEquals(3, counter);
1470
1471 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1472 // catchReturns]
1473
1474 f = function f_____trf_cr_______ () {
1475 var local = 3;
1476 deopt = false;
1477 try {
1478 counter++;
1479 return increaseAndReturn15();
1480 return increaseAndThrow42();
1481 counter++;
1482 } catch (ex) {
1483 counter++;
1484 return 2 + ex;
1485 counter++;
1486 }
1487 counter++;
1488 }
1489 resetOptAndAssertResultEquals(15, f);
1490 assertEquals(2, counter);
1491
1492 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1493 // catchReturns, doFinally]
1494
1495 f = function f_____trf_cr__f____ () {
1496 var local = 3;
1497 deopt = false;
1498 try {
1499 counter++;
1500 return increaseAndReturn15();
1501 return increaseAndThrow42();
1502 counter++;
1503 } catch (ex) {
1504 counter++;
1505 return 2 + ex;
1506 counter++;
1507 } finally {
1508 counter++;
1509 local += 2;
1510 counter++;
1511 }
1512 counter++;
1513 }
1514 resetOptAndAssertResultEquals(15, f);
1515 assertEquals(4, counter);
1516
1517 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1518 // catchReturns, doFinally, finallyThrows]
1519
1520 f = function f_____trf_cr__f_t__ () {
1521 var local = 3;
1522 deopt = false;
1523 try {
1524 counter++;
1525 return increaseAndReturn15();
1526 return increaseAndThrow42();
1527 counter++;
1528 } catch (ex) {
1529 counter++;
1530 return 2 + ex;
1531 counter++;
1532 } finally {
1533 counter++;
1534 throw 25;
1535 counter++;
1536 }
1537 counter++;
1538 }
1539 resetOptAndAssertThrowsWith(25, f);
1540 assertEquals(3, counter);
1541
1542 // Variant flags: [tryThrows, tryReturns, tryFirstReturns, doCatch,
1543 // catchReturns, doFinally, finallyReturns]
1544
1545 f = function f_____trf_cr__fr___ () {
1546 var local = 3;
1547 deopt = false;
1548 try {
1549 counter++;
1550 return increaseAndReturn15();
1551 return increaseAndThrow42();
1552 counter++;
1553 } catch (ex) {
1554 counter++;
1555 return 2 + ex;
1556 counter++;
1557 } finally {
1558 counter++;
1559 return 3 + local;
1560 counter++;
1561 }
1562 counter++;
1563 }
1564 resetOptAndAssertResultEquals(6, f);
1565 assertEquals(3, counter);
1566
1567 // Variant flags: [alternativeFn1, tryReturns, doCatch]
1568
1569 f = function f____1_r__c________ () {
1570 var local = 3;
1571 deopt = false;
1572 try {
1573 counter++;
1574 return returnOrThrow(true);
1575 counter++;
1576 } catch (ex) {
1577 counter++;
1578 counter++;
1579 }
1580 counter++;
1581 }
1582 resetOptAndAssertResultEquals(15, f);
1583 assertEquals(2, counter);
1584
1585 // Variant flags: [alternativeFn1, tryReturns, doCatch, deopt]
1586
1587 f = function f____1_r__c_______d () {
1588 var local = 3;
1589 deopt = true;
1590 try {
1591 counter++;
1592 return returnOrThrow(true);
1593 counter++;
1594 } catch (ex) {
1595 counter++;
1596 counter++;
1597 }
1598 counter++;
1599 }
1600 resetOptAndAssertResultEquals(15, f);
1601 assertEquals(2, counter);
1602
1603 // Variant flags: [alternativeFn1, tryReturns, doCatch, catchThrows]
1604
1605 f = function f____1_r__c__t_____ () {
1606 var local = 3;
1607 deopt = false;
1608 try {
1609 counter++;
1610 return returnOrThrow(true);
1611 counter++;
1612 } catch (ex) {
1613 counter++;
1614 throw 2 + ex;
1615 counter++;
1616 }
1617 counter++;
1618 }
1619 resetOptAndAssertResultEquals(15, f);
1620 assertEquals(2, counter);
1621
1622 // Variant flags: [alternativeFn1, tryReturns, doCatch, catchThrows,
1623 // deopt]
1624
1625 f = function f____1_r__c__t____d () {
1626 var local = 3;
1627 deopt = true;
1628 try {
1629 counter++;
1630 return returnOrThrow(true);
1631 counter++;
1632 } catch (ex) {
1633 counter++;
1634 throw 2 + ex;
1635 counter++;
1636 }
1637 counter++;
1638 }
1639 resetOptAndAssertResultEquals(15, f);
1640 assertEquals(2, counter);
1641
1642 // Variant flags: [alternativeFn1, tryReturns, doCatch,
1643 // catchReturns]
1644
1645 f = function f____1_r__cr_______ () {
1646 var local = 3;
1647 deopt = false;
1648 try {
1649 counter++;
1650 return returnOrThrow(true);
1651 counter++;
1652 } catch (ex) {
1653 counter++;
1654 return 2 + ex;
1655 counter++;
1656 }
1657 counter++;
1658 }
1659 resetOptAndAssertResultEquals(15, f);
1660 assertEquals(2, counter);
1661
1662 // Variant flags: [alternativeFn1, tryReturns, doCatch,
1663 // catchReturns, deopt]
1664
1665 f = function f____1_r__cr______d () {
1666 var local = 3;
1667 deopt = true;
1668 try {
1669 counter++;
1670 return returnOrThrow(true);
1671 counter++;
1672 } catch (ex) {
1673 counter++;
1674 return 2 + ex;
1675 counter++;
1676 }
1677 counter++;
1678 }
1679 resetOptAndAssertResultEquals(15, f);
1680 assertEquals(2, counter);
1681
1682 // Variant flags: [alternativeFn1, tryThrows, doCatch]
1683
1684 f = function f____1t___c________ () {
1685 var local = 3;
1686 deopt = false;
1687 try {
1688 counter++;
1689 return returnOrThrow(false);
1690 counter++;
1691 } catch (ex) {
1692 counter++;
1693 counter++;
1694 }
1695 counter++;
1696 }
1697 resetOptAndAssertResultEquals(undefined, f);
1698 assertEquals(5, counter);
1699
1700 // Variant flags: [alternativeFn1, tryThrows, doCatch, deopt]
1701
1702 f = function f____1t___c_______d () {
1703 var local = 3;
1704 deopt = true;
1705 try {
1706 counter++;
1707 return returnOrThrow(false);
1708 counter++;
1709 } catch (ex) {
1710 counter++;
1711 counter++;
1712 }
1713 counter++;
1714 }
1715 resetOptAndAssertResultEquals(undefined, f);
1716 assertEquals(5, counter);
1717
1718 // Variant flags: [alternativeFn1, tryThrows, doCatch, catchThrows]
1719
1720 f = function f____1t___c__t_____ () {
1721 var local = 3;
1722 deopt = false;
1723 try {
1724 counter++;
1725 return returnOrThrow(false);
1726 counter++;
1727 } catch (ex) {
1728 counter++;
1729 throw 2 + ex;
1730 counter++;
1731 }
1732 counter++;
1733 }
1734 resetOptAndAssertThrowsWith(44, f);
1735 assertEquals(3, counter);
1736
1737 // Variant flags: [alternativeFn1, tryThrows, doCatch, catchThrows,
1738 // deopt]
1739
1740 f = function f____1t___c__t____d () {
1741 var local = 3;
1742 deopt = true;
1743 try {
1744 counter++;
1745 return returnOrThrow(false);
1746 counter++;
1747 } catch (ex) {
1748 counter++;
1749 throw 2 + ex;
1750 counter++;
1751 }
1752 counter++;
1753 }
1754 resetOptAndAssertThrowsWith(44, f);
1755 assertEquals(3, counter);
1756
1757 // Variant flags: [alternativeFn1, tryThrows, doCatch, catchReturns]
1758
1759 f = function f____1t___cr_______ () {
1760 var local = 3;
1761 deopt = false;
1762 try {
1763 counter++;
1764 return returnOrThrow(false);
1765 counter++;
1766 } catch (ex) {
1767 counter++;
1768 return 2 + ex;
1769 counter++;
1770 }
1771 counter++;
1772 }
1773 resetOptAndAssertResultEquals(44, f);
1774 assertEquals(3, counter);
1775
1776 // Variant flags: [alternativeFn1, tryThrows, doCatch, catchReturns,
1777 // deopt]
1778
1779 f = function f____1t___cr______d () {
1780 var local = 3;
1781 deopt = true;
1782 try {
1783 counter++;
1784 return returnOrThrow(false);
1785 counter++;
1786 } catch (ex) {
1787 counter++;
1788 return 2 + ex;
1789 counter++;
1790 }
1791 counter++;
1792 }
1793 resetOptAndAssertResultEquals(44, f);
1794 assertEquals(3, counter);
1795
1796 // Variant flags: [alternativeFn2, tryReturns, doCatch]
1797
1798 f = function f___2__r__c________ () {
1799 var local = 3;
1800 deopt = false;
1801 try {
1802 counter++;
1803 return invertFunctionCall(increaseAndThrow42);
1804 counter++;
1805 } catch (ex) {
1806 counter++;
1807 counter++;
1808 }
1809 counter++;
1810 }
1811 resetOptAndAssertResultEquals(15, f);
1812 assertEquals(2, counter);
1813
1814 // Variant flags: [alternativeFn2, tryReturns, doCatch, deopt]
1815
1816 f = function f___2__r__c_______d () {
1817 var local = 3;
1818 deopt = true;
1819 try {
1820 counter++;
1821 return invertFunctionCall(increaseAndThrow42);
1822 counter++;
1823 } catch (ex) {
1824 counter++;
1825 counter++;
1826 }
1827 counter++;
1828 }
1829 resetOptAndAssertResultEquals(15, f);
1830 assertEquals(2, counter);
1831
1832 // Variant flags: [alternativeFn2, tryReturns, doCatch, catchThrows]
1833
1834 f = function f___2__r__c__t_____ () {
1835 var local = 3;
1836 deopt = false;
1837 try {
1838 counter++;
1839 return invertFunctionCall(increaseAndThrow42);
1840 counter++;
1841 } catch (ex) {
1842 counter++;
1843 throw 2 + ex;
1844 counter++;
1845 }
1846 counter++;
1847 }
1848 resetOptAndAssertResultEquals(15, f);
1849 assertEquals(2, counter);
1850
1851 // Variant flags: [alternativeFn2, tryReturns, doCatch, catchThrows,
1852 // deopt]
1853
1854 f = function f___2__r__c__t____d () {
1855 var local = 3;
1856 deopt = true;
1857 try {
1858 counter++;
1859 return invertFunctionCall(increaseAndThrow42);
1860 counter++;
1861 } catch (ex) {
1862 counter++;
1863 throw 2 + ex;
1864 counter++;
1865 }
1866 counter++;
1867 }
1868 resetOptAndAssertResultEquals(15, f);
1869 assertEquals(2, counter);
1870
1871 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1872 // catchWithLocal]
1873
1874 f = function f___2__r__c_l______ () {
1875 var local = 3;
1876 deopt = false;
1877 try {
1878 counter++;
1879 return invertFunctionCall(increaseAndThrow42);
1880 counter++;
1881 } catch (ex) {
1882 counter++;
1883 local += ex;
1884 counter++;
1885 }
1886 counter++;
1887 }
1888 resetOptAndAssertResultEquals(15, f);
1889 assertEquals(2, counter);
1890
1891 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1892 // catchWithLocal, deopt]
1893
1894 f = function f___2__r__c_l_____d () {
1895 var local = 3;
1896 deopt = true;
1897 try {
1898 counter++;
1899 return invertFunctionCall(increaseAndThrow42);
1900 counter++;
1901 } catch (ex) {
1902 counter++;
1903 local += ex;
1904 counter++;
1905 }
1906 counter++;
1907 }
1908 resetOptAndAssertResultEquals(15, f);
1909 assertEquals(2, counter);
1910
1911 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1912 // catchWithLocal, endReturnLocal]
1913
1914 f = function f___2__r__c_l____l_ () {
1915 var local = 3;
1916 deopt = false;
1917 try {
1918 counter++;
1919 return invertFunctionCall(increaseAndThrow42);
1920 counter++;
1921 } catch (ex) {
1922 counter++;
1923 local += ex;
1924 counter++;
1925 }
1926 counter++;
1927 return 5 + local;
1928 }
1929 resetOptAndAssertResultEquals(15, f);
1930 assertEquals(2, counter);
1931
1932 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1933 // catchWithLocal, endReturnLocal, deopt]
1934
1935 f = function f___2__r__c_l____ld () {
1936 var local = 3;
1937 deopt = true;
1938 try {
1939 counter++;
1940 return invertFunctionCall(increaseAndThrow42);
1941 counter++;
1942 } catch (ex) {
1943 counter++;
1944 local += ex;
1945 counter++;
1946 }
1947 counter++;
1948 return 5 + local;
1949 }
1950 resetOptAndAssertResultEquals(15, f);
1951 assertEquals(2, counter);
1952
1953 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1954 // catchWithLocal, catchThrows]
1955
1956 f = function f___2__r__c_lt_____ () {
1957 var local = 3;
1958 deopt = false;
1959 try {
1960 counter++;
1961 return invertFunctionCall(increaseAndThrow42);
1962 counter++;
1963 } catch (ex) {
1964 counter++;
1965 throw 2 + ex;
1966 counter++;
1967 }
1968 counter++;
1969 }
1970 resetOptAndAssertResultEquals(15, f);
1971 assertEquals(2, counter);
1972
1973 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1974 // catchWithLocal, catchThrows, deopt]
1975
1976 f = function f___2__r__c_lt____d () {
1977 var local = 3;
1978 deopt = true;
1979 try {
1980 counter++;
1981 return invertFunctionCall(increaseAndThrow42);
1982 counter++;
1983 } catch (ex) {
1984 counter++;
1985 throw 2 + ex;
1986 counter++;
1987 }
1988 counter++;
1989 }
1990 resetOptAndAssertResultEquals(15, f);
1991 assertEquals(2, counter);
1992
1993 // Variant flags: [alternativeFn2, tryReturns, doCatch,
1994 // catchWithLocal, catchThrows, endReturnLocal]
1995
1996 f = function f___2__r__c_lt___l_ () {
1997 var local = 3;
1998 deopt = false;
1999 try {
2000 counter++;
2001 return invertFunctionCall(increaseAndThrow42);
2002 counter++;
2003 } catch (ex) {
2004 counter++;
2005 throw 2 + ex;
2006 counter++;
2007 }
2008 counter++;
2009 return 5 + local;
2010 }
2011 resetOptAndAssertResultEquals(15, f);
2012 assertEquals(2, counter);
2013
2014 // Variant flags: [alternativeFn2, tryReturns, doCatch,
2015 // catchWithLocal, catchThrows, endReturnLocal, deopt]
2016
2017 f = function f___2__r__c_lt___ld () {
2018 var local = 3;
2019 deopt = true;
2020 try {
2021 counter++;
2022 return invertFunctionCall(increaseAndThrow42);
2023 counter++;
2024 } catch (ex) {
2025 counter++;
2026 throw 2 + ex;
2027 counter++;
2028 }
2029 counter++;
2030 return 5 + local;
2031 }
2032 resetOptAndAssertResultEquals(15, f);
2033 assertEquals(2, counter);
2034
2035 // Variant flags: [alternativeFn2, tryReturns, doCatch,
2036 // catchReturns]
2037
2038 f = function f___2__r__cr_______ () {
2039 var local = 3;
2040 deopt = false;
2041 try {
2042 counter++;
2043 return invertFunctionCall(increaseAndThrow42);
2044 counter++;
2045 } catch (ex) {
2046 counter++;
2047 return 2 + ex;
2048 counter++;
2049 }
2050 counter++;
2051 }
2052 resetOptAndAssertResultEquals(15, f);
2053 assertEquals(2, counter);
2054
2055 // Variant flags: [alternativeFn2, tryReturns, doCatch,
2056 // catchReturns, deopt]
2057
2058 f = function f___2__r__cr______d () {
2059 var local = 3;
2060 deopt = true;
2061 try {
2062 counter++;
2063 return invertFunctionCall(increaseAndThrow42);
2064 counter++;
2065 } catch (ex) {
2066 counter++;
2067 return 2 + ex;
2068 counter++;
2069 }
2070 counter++;
2071 }
2072 resetOptAndAssertResultEquals(15, f);
2073 assertEquals(2, counter);
2074
2075 // Variant flags: [alternativeFn2, tryReturns, doCatch,
2076 // catchReturns, catchWithLocal]
2077
2078 f = function f___2__r__crl______ () {
2079 var local = 3;
2080 deopt = false;
2081 try {
2082 counter++;
2083 return invertFunctionCall(increaseAndThrow42);
2084 counter++;
2085 } catch (ex) {
2086 counter++;
2087 return 2 + local;
2088 counter++;
2089 }
2090 counter++;
2091 }
2092 resetOptAndAssertResultEquals(15, f);
2093 assertEquals(2, counter);
2094
2095 // Variant flags: [alternativeFn2, tryReturns, doCatch,
2096 // catchReturns, catchWithLocal, deopt]
2097
2098 f = function f___2__r__crl_____d () {
2099 var local = 3;
2100 deopt = true;
2101 try {
2102 counter++;
2103 return invertFunctionCall(increaseAndThrow42);
2104 counter++;
2105 } catch (ex) {
2106 counter++;
2107 return 2 + local;
2108 counter++;
2109 }
2110 counter++;
2111 }
2112 resetOptAndAssertResultEquals(15, f);
2113 assertEquals(2, counter);
2114
2115 }
2116 %NeverOptimizeFunction(runThisShard);
2117
2118 // 94 tests in this shard.
2119 // 94 tests up to here.
2120
2121 runThisShard();
OLDNEW
« no previous file with comments | « no previous file | test/mjsunit/compiler/inline-exception-2.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698