1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #include <stdlib.h>
29
30 #include "v8.h"
31
32 #include "api.h"
33 #include "cctest.h"
34 #include "compilation-cache.h"
35 #include "debug.h"
36 #include "deoptimizer.h"
37 #include "isolate.h"
38 #include "platform.h"
39 #include "stub-cache.h"
40
41 using ::v8::internal::Deoptimizer;
42 using ::v8::internal::EmbeddedVector;
43 using ::v8::internal::Handle;
44 using ::v8::internal::Isolate;
45 using ::v8::internal::JSFunction;
46 using ::v8::internal::OS;
47 using ::v8::internal::Object;
48
49 // Size of temp buffer for formatting small strings.
50 #define SMALL_STRING_BUFFER_SIZE 80
51
52 // Utility class to set --allow-natives-syntax --always-opt and --nouse-inlining
53 // when constructed and return to their default state when destroyed.
54 class AlwaysOptimizeAllowNativesSyntaxNoInlining {
55 public:
AlwaysOptimizeAllowNativesSyntaxNoInlining()56 AlwaysOptimizeAllowNativesSyntaxNoInlining()
57 : always_opt_(i::FLAG_always_opt),
58 allow_natives_syntax_(i::FLAG_allow_natives_syntax),
59 use_inlining_(i::FLAG_use_inlining) {
60 i::FLAG_always_opt = true;
61 i::FLAG_allow_natives_syntax = true;
62 i::FLAG_use_inlining = false;
63 }
64
~AlwaysOptimizeAllowNativesSyntaxNoInlining()65 ~AlwaysOptimizeAllowNativesSyntaxNoInlining() {
66 i::FLAG_allow_natives_syntax = allow_natives_syntax_;
67 i::FLAG_always_opt = always_opt_;
68 i::FLAG_use_inlining = use_inlining_;
69 }
70
71 private:
72 bool always_opt_;
73 bool allow_natives_syntax_;
74 bool use_inlining_;
75 };
76
77
78 // Utility class to set --allow-natives-syntax and --nouse-inlining when
79 // constructed and return to their default state when destroyed.
80 class AllowNativesSyntaxNoInlining {
81 public:
AllowNativesSyntaxNoInlining()82 AllowNativesSyntaxNoInlining()
83 : allow_natives_syntax_(i::FLAG_allow_natives_syntax),
84 use_inlining_(i::FLAG_use_inlining) {
85 i::FLAG_allow_natives_syntax = true;
86 i::FLAG_use_inlining = false;
87 }
88
~AllowNativesSyntaxNoInlining()89 ~AllowNativesSyntaxNoInlining() {
90 i::FLAG_allow_natives_syntax = allow_natives_syntax_;
91 i::FLAG_use_inlining = use_inlining_;
92 }
93
94 private:
95 bool allow_natives_syntax_;
96 bool use_inlining_;
97 };
98
99
100 // Abort any ongoing incremental marking to make sure that all weak global
101 // handle callbacks are processed.
NonIncrementalGC()102 static void NonIncrementalGC() {
103 HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
104 }
105
106
GetJSFunction(v8::Handle<v8::Object> obj,const char * property_name)107 static Handle<JSFunction> GetJSFunction(v8::Handle<v8::Object> obj,
108 const char* property_name) {
109 v8::Local<v8::Function> fun =
110 v8::Local<v8::Function>::Cast(obj->Get(v8_str(property_name)));
111 return v8::Utils::OpenHandle(*fun);
112 }
113
114
TEST(DeoptimizeSimple)115 TEST(DeoptimizeSimple) {
116 v8::HandleScope scope;
117 LocalContext env;
118
119 // Test lazy deoptimization of a simple function.
120 {
121 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
122 CompileRun(
123 "var count = 0;"
124 "function h() { %DeoptimizeFunction(f); }"
125 "function g() { count++; h(); }"
126 "function f() { g(); };"
127 "f();");
128 }
129 NonIncrementalGC();
130
131 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
132 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
133 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
134
135 // Test lazy deoptimization of a simple function. Call the function after the
136 // deoptimization while it is still activated further down the stack.
137 {
138 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
139 CompileRun(
140 "var count = 0;"
141 "function g() { count++; %DeoptimizeFunction(f); f(false); }"
142 "function f(x) { if (x) { g(); } else { return } };"
143 "f(true);");
144 }
145 NonIncrementalGC();
146
147 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
148 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
149 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
150 }
151
152
TEST(DeoptimizeSimpleWithArguments)153 TEST(DeoptimizeSimpleWithArguments) {
154 v8::HandleScope scope;
155 LocalContext env;
156
157 // Test lazy deoptimization of a simple function with some arguments.
158 {
159 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
160 CompileRun(
161 "var count = 0;"
162 "function h(x) { %DeoptimizeFunction(f); }"
163 "function g(x, y) { count++; h(x); }"
164 "function f(x, y, z) { g(1,x); y+z; };"
165 "f(1, \"2\", false);");
166 }
167 NonIncrementalGC();
168
169 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
170 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
171 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
172
173 // Test lazy deoptimization of a simple function with some arguments. Call the
174 // function after the deoptimization while it is still activated further down
175 // the stack.
176 {
177 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
178 CompileRun(
179 "var count = 0;"
180 "function g(x, y) { count++; %DeoptimizeFunction(f); f(false, 1, y); }"
181 "function f(x, y, z) { if (x) { g(x, y); } else { return y + z; } };"
182 "f(true, 1, \"2\");");
183 }
184 NonIncrementalGC();
185
186 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
187 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
188 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
189 }
190
191
TEST(DeoptimizeSimpleNested)192 TEST(DeoptimizeSimpleNested) {
193 v8::HandleScope scope;
194 LocalContext env;
195
196 // Test lazy deoptimization of a simple function. Have a nested function call
197 // do the deoptimization.
198 {
199 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
200 CompileRun(
201 "var count = 0;"
202 "var result = 0;"
203 "function h(x, y, z) { return x + y + z; }"
204 "function g(z) { count++; %DeoptimizeFunction(f); return z;}"
205 "function f(x,y,z) { return h(x, y, g(z)); };"
206 "result = f(1, 2, 3);");
207 NonIncrementalGC();
208
209 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
210 CHECK_EQ(6, env->Global()->Get(v8_str("result"))->Int32Value());
211 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
212 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
213 }
214 }
215
216
TEST(DeoptimizeRecursive)217 TEST(DeoptimizeRecursive) {
218 v8::HandleScope scope;
219 LocalContext env;
220
221 {
222 // Test lazy deoptimization of a simple function called recursively. Call
223 // the function recursively a number of times before deoptimizing it.
224 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
225 CompileRun(
226 "var count = 0;"
227 "var calls = 0;"
228 "function g() { count++; %DeoptimizeFunction(f); }"
229 "function f(x) { calls++; if (x > 0) { f(x - 1); } else { g(); } };"
230 "f(10);");
231 }
232 NonIncrementalGC();
233
234 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
235 CHECK_EQ(11, env->Global()->Get(v8_str("calls"))->Int32Value());
236 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
237
238 v8::Local<v8::Function> fun =
239 v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
240 CHECK(!fun.IsEmpty());
241 }
242
243
TEST(DeoptimizeMultiple)244 TEST(DeoptimizeMultiple) {
245 v8::HandleScope scope;
246 LocalContext env;
247
248 {
249 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
250 CompileRun(
251 "var count = 0;"
252 "var result = 0;"
253 "function g() { count++;"
254 " %DeoptimizeFunction(f1);"
255 " %DeoptimizeFunction(f2);"
256 " %DeoptimizeFunction(f3);"
257 " %DeoptimizeFunction(f4);}"
258 "function f4(x) { g(); };"
259 "function f3(x, y, z) { f4(); return x + y + z; };"
260 "function f2(x, y) { return x + f3(y + 1, y + 1, y + 1) + y; };"
261 "function f1(x) { return f2(x + 1, x + 1) + x; };"
262 "result = f1(1);");
263 }
264 NonIncrementalGC();
265
266 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
267 CHECK_EQ(14, env->Global()->Get(v8_str("result"))->Int32Value());
268 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
269 }
270
271
TEST(DeoptimizeConstructor)272 TEST(DeoptimizeConstructor) {
273 v8::HandleScope scope;
274 LocalContext env;
275
276 {
277 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
278 CompileRun(
279 "var count = 0;"
280 "function g() { count++;"
281 " %DeoptimizeFunction(f); }"
282 "function f() { g(); };"
283 "result = new f() instanceof f;");
284 }
285 NonIncrementalGC();
286
287 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
288 CHECK(env->Global()->Get(v8_str("result"))->IsTrue());
289 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
290
291 {
292 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
293 CompileRun(
294 "var count = 0;"
295 "var result = 0;"
296 "function g() { count++;"
297 " %DeoptimizeFunction(f); }"
298 "function f(x, y) { this.x = x; g(); this.y = y; };"
299 "result = new f(1, 2);"
300 "result = result.x + result.y;");
301 }
302 NonIncrementalGC();
303
304 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
305 CHECK_EQ(3, env->Global()->Get(v8_str("result"))->Int32Value());
306 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
307 }
308
309
TEST(DeoptimizeConstructorMultiple)310 TEST(DeoptimizeConstructorMultiple) {
311 v8::HandleScope scope;
312 LocalContext env;
313
314 {
315 AlwaysOptimizeAllowNativesSyntaxNoInlining options;
316 CompileRun(
317 "var count = 0;"
318 "var result = 0;"
319 "function g() { count++;"
320 " %DeoptimizeFunction(f1);"
321 " %DeoptimizeFunction(f2);"
322 " %DeoptimizeFunction(f3);"
323 " %DeoptimizeFunction(f4);}"
324 "function f4(x) { this.result = x; g(); };"
325 "function f3(x, y, z) { this.result = new f4(x + y + z).result; };"
326 "function f2(x, y) {"
327 " this.result = x + new f3(y + 1, y + 1, y + 1).result + y; };"
328 "function f1(x) { this.result = new f2(x + 1, x + 1).result + x; };"
329 "result = new f1(1).result;");
330 }
331 NonIncrementalGC();
332
333 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
334 CHECK_EQ(14, env->Global()->Get(v8_str("result"))->Int32Value());
335 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
336 }
337
338
TEST(DeoptimizeBinaryOperationADDString)339 TEST(DeoptimizeBinaryOperationADDString) {
340 v8::HandleScope scope;
341 LocalContext env;
342
343 const char* f_source = "function f(x, y) { return x + y; };";
344
345 {
346 AllowNativesSyntaxNoInlining options;
347 // Compile function f and collect to type feedback to insert binary op stub
348 // call in the optimized code.
349 i::FLAG_prepare_always_opt = true;
350 CompileRun("var count = 0;"
351 "var result = 0;"
352 "var deopt = false;"
353 "function X() { };"
354 "X.prototype.toString = function () {"
355 " if (deopt) { count++; %DeoptimizeFunction(f); } return 'an X'"
356 "};");
357 CompileRun(f_source);
358 CompileRun("for (var i = 0; i < 5; i++) {"
359 " f('a+', new X());"
360 "};");
361
362 // Compile an optimized version of f.
363 i::FLAG_always_opt = true;
364 CompileRun(f_source);
365 CompileRun("f('a+', new X());");
366 CHECK(!i::V8::UseCrankshaft() ||
367 GetJSFunction(env->Global(), "f")->IsOptimized());
368
369 // Call f and force deoptimization while processing the binary operation.
370 CompileRun("deopt = true;"
371 "var result = f('a+', new X());");
372 }
373 NonIncrementalGC();
374
375 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
376 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
377 v8::Handle<v8::Value> result = env->Global()->Get(v8_str("result"));
378 CHECK(result->IsString());
379 v8::String::AsciiValue ascii(result);
380 CHECK_EQ("a+an X", *ascii);
381 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
382 }
383
384
CompileConstructorWithDeoptimizingValueOf()385 static void CompileConstructorWithDeoptimizingValueOf() {
386 CompileRun("var count = 0;"
387 "var result = 0;"
388 "var deopt = false;"
389 "function X() { };"
390 "X.prototype.valueOf = function () {"
391 " if (deopt) { count++; %DeoptimizeFunction(f); } return 8"
392 "};");
393 }
394
395
TestDeoptimizeBinaryOpHelper(LocalContext * env,const char * binary_op)396 static void TestDeoptimizeBinaryOpHelper(LocalContext* env,
397 const char* binary_op) {
398 EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> f_source_buffer;
399 OS::SNPrintF(f_source_buffer,
400 "function f(x, y) { return x %s y; };",
401 binary_op);
402 char* f_source = f_source_buffer.start();
403
404 AllowNativesSyntaxNoInlining options;
405 // Compile function f and collect to type feedback to insert binary op stub
406 // call in the optimized code.
407 i::FLAG_prepare_always_opt = true;
408 CompileConstructorWithDeoptimizingValueOf();
409 CompileRun(f_source);
410 CompileRun("for (var i = 0; i < 5; i++) {"
411 " f(8, new X());"
412 "};");
413
414 // Compile an optimized version of f.
415 i::FLAG_always_opt = true;
416 CompileRun(f_source);
417 CompileRun("f(7, new X());");
418 CHECK(!i::V8::UseCrankshaft() ||
419 GetJSFunction((*env)->Global(), "f")->IsOptimized());
420
421 // Call f and force deoptimization while processing the binary operation.
422 CompileRun("deopt = true;"
423 "var result = f(7, new X());");
424 NonIncrementalGC();
425 CHECK(!GetJSFunction((*env)->Global(), "f")->IsOptimized());
426 }
427
428
TEST(DeoptimizeBinaryOperationADD)429 TEST(DeoptimizeBinaryOperationADD) {
430 v8::HandleScope scope;
431 LocalContext env;
432
433 TestDeoptimizeBinaryOpHelper(&env, "+");
434
435 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
436 CHECK_EQ(15, env->Global()->Get(v8_str("result"))->Int32Value());
437 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
438 }
439
440
TEST(DeoptimizeBinaryOperationSUB)441 TEST(DeoptimizeBinaryOperationSUB) {
442 v8::HandleScope scope;
443 LocalContext env;
444
445 TestDeoptimizeBinaryOpHelper(&env, "-");
446
447 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
448 CHECK_EQ(-1, env->Global()->Get(v8_str("result"))->Int32Value());
449 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
450 }
451
452
TEST(DeoptimizeBinaryOperationMUL)453 TEST(DeoptimizeBinaryOperationMUL) {
454 v8::HandleScope scope;
455 LocalContext env;
456
457 TestDeoptimizeBinaryOpHelper(&env, "*");
458
459 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
460 CHECK_EQ(56, env->Global()->Get(v8_str("result"))->Int32Value());
461 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
462 }
463
464
TEST(DeoptimizeBinaryOperationDIV)465 TEST(DeoptimizeBinaryOperationDIV) {
466 v8::HandleScope scope;
467 LocalContext env;
468
469 TestDeoptimizeBinaryOpHelper(&env, "/");
470
471 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
472 CHECK_EQ(0, env->Global()->Get(v8_str("result"))->Int32Value());
473 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
474 }
475
476
TEST(DeoptimizeBinaryOperationMOD)477 TEST(DeoptimizeBinaryOperationMOD) {
478 v8::HandleScope scope;
479 LocalContext env;
480
481 TestDeoptimizeBinaryOpHelper(&env, "%");
482
483 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
484 CHECK_EQ(7, env->Global()->Get(v8_str("result"))->Int32Value());
485 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
486 }
487
488
TEST(DeoptimizeCompare)489 TEST(DeoptimizeCompare) {
490 v8::HandleScope scope;
491 LocalContext env;
492
493 const char* f_source = "function f(x, y) { return x < y; };";
494
495 {
496 AllowNativesSyntaxNoInlining options;
497 // Compile function f and collect to type feedback to insert compare ic
498 // call in the optimized code.
499 i::FLAG_prepare_always_opt = true;
500 CompileRun("var count = 0;"
501 "var result = 0;"
502 "var deopt = false;"
503 "function X() { };"
504 "X.prototype.toString = function () {"
505 " if (deopt) { count++; %DeoptimizeFunction(f); } return 'b'"
506 "};");
507 CompileRun(f_source);
508 CompileRun("for (var i = 0; i < 5; i++) {"
509 " f('a', new X());"
510 "};");
511
512 // Compile an optimized version of f.
513 i::FLAG_always_opt = true;
514 CompileRun(f_source);
515 CompileRun("f('a', new X());");
516 CHECK(!i::V8::UseCrankshaft() ||
517 GetJSFunction(env->Global(), "f")->IsOptimized());
518
519 // Call f and force deoptimization while processing the comparison.
520 CompileRun("deopt = true;"
521 "var result = f('a', new X());");
522 }
523 NonIncrementalGC();
524
525 CHECK(!GetJSFunction(env->Global(), "f")->IsOptimized());
526 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
527 CHECK_EQ(true, env->Global()->Get(v8_str("result"))->BooleanValue());
528 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
529 }
530
531
TEST(DeoptimizeLoadICStoreIC)532 TEST(DeoptimizeLoadICStoreIC) {
533 v8::HandleScope scope;
534 LocalContext env;
535
536 // Functions to generate load/store/keyed load/keyed store IC calls.
537 const char* f1_source = "function f1(x) { return x.y; };";
538 const char* g1_source = "function g1(x) { x.y = 1; };";
539 const char* f2_source = "function f2(x, y) { return x[y]; };";
540 const char* g2_source = "function g2(x, y) { x[y] = 1; };";
541
542 {
543 AllowNativesSyntaxNoInlining options;
544 // Compile functions and collect to type feedback to insert ic
545 // calls in the optimized code.
546 i::FLAG_prepare_always_opt = true;
547 CompileRun("var count = 0;"
548 "var result = 0;"
549 "var deopt = false;"
550 "function X() { };"
551 "X.prototype.__defineGetter__('y', function () {"
552 " if (deopt) { count++; %DeoptimizeFunction(f1); };"
553 " return 13;"
554 "});"
555 "X.prototype.__defineSetter__('y', function () {"
556 " if (deopt) { count++; %DeoptimizeFunction(g1); };"
557 "});"
558 "X.prototype.__defineGetter__('z', function () {"
559 " if (deopt) { count++; %DeoptimizeFunction(f2); };"
560 " return 13;"
561 "});"
562 "X.prototype.__defineSetter__('z', function () {"
563 " if (deopt) { count++; %DeoptimizeFunction(g2); };"
564 "});");
565 CompileRun(f1_source);
566 CompileRun(g1_source);
567 CompileRun(f2_source);
568 CompileRun(g2_source);
569 CompileRun("for (var i = 0; i < 5; i++) {"
570 " f1(new X());"
571 " g1(new X());"
572 " f2(new X(), 'z');"
573 " g2(new X(), 'z');"
574 "};");
575
576 // Compile an optimized version of the functions.
577 i::FLAG_always_opt = true;
578 CompileRun(f1_source);
579 CompileRun(g1_source);
580 CompileRun(f2_source);
581 CompileRun(g2_source);
582 CompileRun("f1(new X());");
583 CompileRun("g1(new X());");
584 CompileRun("f2(new X(), 'z');");
585 CompileRun("g2(new X(), 'z');");
586 if (i::V8::UseCrankshaft()) {
587 CHECK(GetJSFunction(env->Global(), "f1")->IsOptimized());
588 CHECK(GetJSFunction(env->Global(), "g1")->IsOptimized());
589 CHECK(GetJSFunction(env->Global(), "f2")->IsOptimized());
590 CHECK(GetJSFunction(env->Global(), "g2")->IsOptimized());
591 }
592
593 // Call functions and force deoptimization while processing the ics.
594 CompileRun("deopt = true;"
595 "var result = f1(new X());"
596 "g1(new X());"
597 "f2(new X(), 'z');"
598 "g2(new X(), 'z');");
599 }
600 NonIncrementalGC();
601
602 CHECK(!GetJSFunction(env->Global(), "f1")->IsOptimized());
603 CHECK(!GetJSFunction(env->Global(), "g1")->IsOptimized());
604 CHECK(!GetJSFunction(env->Global(), "f2")->IsOptimized());
605 CHECK(!GetJSFunction(env->Global(), "g2")->IsOptimized());
606 CHECK_EQ(4, env->Global()->Get(v8_str("count"))->Int32Value());
607 CHECK_EQ(13, env->Global()->Get(v8_str("result"))->Int32Value());
608 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
609 }
610
611
TEST(DeoptimizeLoadICStoreICNested)612 TEST(DeoptimizeLoadICStoreICNested) {
613 v8::HandleScope scope;
614 LocalContext env;
615
616 // Functions to generate load/store/keyed load/keyed store IC calls.
617 const char* f1_source = "function f1(x) { return x.y; };";
618 const char* g1_source = "function g1(x) { x.y = 1; };";
619 const char* f2_source = "function f2(x, y) { return x[y]; };";
620 const char* g2_source = "function g2(x, y) { x[y] = 1; };";
621
622 {
623 AllowNativesSyntaxNoInlining options;
624 // Compile functions and collect to type feedback to insert ic
625 // calls in the optimized code.
626 i::FLAG_prepare_always_opt = true;
627 CompileRun("var count = 0;"
628 "var result = 0;"
629 "var deopt = false;"
630 "function X() { };"
631 "X.prototype.__defineGetter__('y', function () {"
632 " g1(this);"
633 " return 13;"
634 "});"
635 "X.prototype.__defineSetter__('y', function () {"
636 " f2(this, 'z');"
637 "});"
638 "X.prototype.__defineGetter__('z', function () {"
639 " g2(this, 'z');"
640 "});"
641 "X.prototype.__defineSetter__('z', function () {"
642 " if (deopt) {"
643 " count++;"
644 " %DeoptimizeFunction(f1);"
645 " %DeoptimizeFunction(g1);"
646 " %DeoptimizeFunction(f2);"
647 " %DeoptimizeFunction(g2); };"
648 "});");
649 CompileRun(f1_source);
650 CompileRun(g1_source);
651 CompileRun(f2_source);
652 CompileRun(g2_source);
653 CompileRun("for (var i = 0; i < 5; i++) {"
654 " f1(new X());"
655 " g1(new X());"
656 " f2(new X(), 'z');"
657 " g2(new X(), 'z');"
658 "};");
659
660 // Compile an optimized version of the functions.
661 i::FLAG_always_opt = true;
662 CompileRun(f1_source);
663 CompileRun(g1_source);
664 CompileRun(f2_source);
665 CompileRun(g2_source);
666 CompileRun("f1(new X());");
667 CompileRun("g1(new X());");
668 CompileRun("f2(new X(), 'z');");
669 CompileRun("g2(new X(), 'z');");
670 if (i::V8::UseCrankshaft()) {
671 CHECK(GetJSFunction(env->Global(), "f1")->IsOptimized());
672 CHECK(GetJSFunction(env->Global(), "g1")->IsOptimized());
673 CHECK(GetJSFunction(env->Global(), "f2")->IsOptimized());
674 CHECK(GetJSFunction(env->Global(), "g2")->IsOptimized());
675 }
676
677 // Call functions and force deoptimization while processing the ics.
678 CompileRun("deopt = true;"
679 "var result = f1(new X());");
680 }
681 NonIncrementalGC();
682
683 CHECK(!GetJSFunction(env->Global(), "f1")->IsOptimized());
684 CHECK(!GetJSFunction(env->Global(), "g1")->IsOptimized());
685 CHECK(!GetJSFunction(env->Global(), "f2")->IsOptimized());
686 CHECK(!GetJSFunction(env->Global(), "g2")->IsOptimized());
687 CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
688 CHECK_EQ(13, env->Global()->Get(v8_str("result"))->Int32Value());
689 CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
690 }
691