From 886c0fa4f7cfba01a6530e386be4d423c0001dd4 Mon Sep 17 00:00:00 2001
From: "mstarzinger@chromium.org"
 <mstarzinger@chromium.org@ce2b1a6d-e550-0410-aec6-3dcde31c8c00>
Date: Thu, 16 Aug 2012 09:13:25 +0000
Subject: [PATCH] Extend constructor inlining test case.

This makes sure that deoptimization really happens in each hydrogen
context by not using binary operations but loads instead. This is
needed because we cannot clear BinaryOpICs explicitly.

R=svenpanne@chromium.org
TEST=mjsunit/compiler/inline-construct

Review URL: https://chromiumcodereview.appspot.com/10825382

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@12315 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
---
 test/mjsunit/compiler/inline-construct.js | 60 +++++++++++++++++--------------
 1 file changed, 34 insertions(+), 26 deletions(-)

diff --git a/test/mjsunit/compiler/inline-construct.js b/test/mjsunit/compiler/inline-construct.js
index f73e891..fa784cf 100644
--- a/test/mjsunit/compiler/inline-construct.js
+++ b/test/mjsunit/compiler/inline-construct.js
@@ -32,43 +32,46 @@
 function TestInlinedConstructor(constructor, closure) {
   var result;
   var counter = { value:0 };
+  var noDeopt = { deopt:0 };
+  var forceDeopt = { /*empty*/ };
 
-  result = closure(constructor, 11, 12, counter);
-  assertEquals(23, result);
+  result = closure(constructor, 11, noDeopt, counter);
+  assertEquals(11, result);
   assertEquals(1, counter.value);
 
-  result = closure(constructor, 23, 19, counter);
-  assertEquals(42, result);
+  result = closure(constructor, 23, noDeopt, counter);
+  assertEquals(23, result);
   assertEquals(2, counter.value);
 
   %OptimizeFunctionOnNextCall(closure);
-  result = closure(constructor, 1, 42, counter);
-  assertEquals(43, result);
+  result = closure(constructor, 42, noDeopt, counter);
+  assertEquals(42, result);
   assertEquals(3, counter.value);
 
-  result = closure(constructor, "foo", "bar", counter);
-  assertEquals("foobar", result)
+  result = closure(constructor, 127, forceDeopt, counter);
+  assertEquals(127, result)
   assertEquals(4, counter.value);
 
   %DeoptimizeFunction(closure);
   %ClearFunctionTypeFeedback(closure);
+  %ClearFunctionTypeFeedback(constructor);
 }
 
-function value_context(constructor, a, b, counter) {
-  var obj = new constructor(a, b, counter);
+function value_context(constructor, val, deopt, counter) {
+  var obj = new constructor(val, deopt, counter);
   return obj.x;
 }
 
-function test_context(constructor, a, b, counter) {
-  if (!new constructor(a, b, counter)) {
+function test_context(constructor, val, deopt, counter) {
+  if (!new constructor(val, deopt, counter)) {
     assertUnreachable("should not happen");
   }
-  return a + b;
+  return val;
 }
 
-function effect_context(constructor, a, b, counter) {
-  new constructor(a, b, counter);
-  return a + b;
+function effect_context(constructor, val, deopt, counter) {
+  new constructor(val, deopt, counter);
+  return val;
 }
 
 function TestInAllContexts(constructor) {
@@ -79,17 +82,19 @@ function TestInAllContexts(constructor) {
 
 
 // Test constructor returning nothing in all contexts.
-function c1(a, b, counter) {
-  this.x = a + b;
+function c1(val, deopt, counter) {
+  deopt.deopt;
+  this.x = val;
   counter.value++;
 }
 TestInAllContexts(c1);
 
 
 // Test constructor returning an object in all contexts.
-function c2(a, b, counter) {
+function c2(val, deopt, counter) {
   var obj = {};
-  obj.x = a + b;
+  deopt.deopt;
+  obj.x = val;
   counter.value++;
   return obj;
 }
@@ -97,8 +102,9 @@ TestInAllContexts(c2);
 
 
 // Test constructor returning a primitive value in all contexts.
-function c3(a, b, counter) {
-  this.x = a + b;
+function c3(val, deopt, counter) {
+  deopt.deopt;
+  this.x = val;
   counter.value++;
   return "not an object";
 }
@@ -137,9 +143,10 @@ assertEquals("foo1", f_too_few("foo"))
 
 
 // Test constructor that cannot be inlined.
-function c_unsupported_syntax(a, b, counter) {
+function c_unsupported_syntax(val, deopt, counter) {
   try {
-    this.x = a + b;
+    deopt.deopt;
+    this.x = val;
     counter.value++;
   } catch(e) {
     throw new Error();
@@ -150,9 +157,10 @@ TestInAllContexts(c_unsupported_syntax);
 
 // Regression test: Inlined constructors called as functions do not get their
 // implicit receiver object set to undefined, even in strict mode.
-function c_strict(a, b, counter) {
+function c_strict(val, deopt, counter) {
   "use strict";
-  this.x = a + b;
+  deopt.deopt;
+  this.x = val;
   counter.value++;
 }
 TestInAllContexts(c_strict);
-- 
2.7.4