Inline loading of immutable properties

test/mjsunit/compiler/immutable-load-inline.js

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --noalways-opt
 
-(function DeoptimizeArgCallFunctionGeneric() {
-  var a = [];
+function GrandGrandParent() {}
+GrandGrandParent.prototype =  Object.freeze({constant: 2});
 
-  function f1(method, array, elem, deopt) {
-    assertEquals('push', method);
-  }
+function GrandParent() {}
+GrandParent.prototype = Object.create(GrandGrandParent.prototype);
 
-  function f2() { }
+function Parent() {}
+Parent.prototype = Object.create(GrandParent.prototype);
 
-  function bar(x, deopt, f) {
-    f('push', a, [x], deopt + 0);
-  }
+function Child() {}
+Child.prototype = Object.create(Parent.prototype);
 
-  function foo() { return bar(arguments[0], arguments[1], arguments[2]); }
-  function baz(f, deopt) { return foo("x", deopt, f); }
-
-  baz(f1, 0);
-  baz(f2, 0);
-  %OptimizeFunctionOnNextCall(baz);
-  baz(f1, "deopt");
-})();
+Child.prototype.method1 = function() {
+  return this.constant * this.constant;
+};
 
 
-(function DeoptimizeArgGlobalFunctionGeneric() {
-  var a = [];
+var a = new Child();
+assertEquals(a.method1(), 4);
+a.method1();
+%OptimizeFunctionOnNextCall(a.method1);
+assertEquals(a.method1(), 4);
+assertEquals(a.method1(), 4);
 
-  var f1;
+// Immutable properties cannot be shadowed so the only way
+// is to snip the whole chain
+a.__proto__.__proto__ = {constant: 4};
 
-  f1 = function(method, array, elem, deopt) {
-    assertEquals('push', method);
-  }
+assertEquals(a.method1(), 16);
+assertEquals(a.method1(), 16);
+%OptimizeFunctionOnNextCall(a.method1);
+assertEquals(a.method1(), 16);
+assertEquals(a.method1(), 16);
 
-  function bar(x, deopt, f) {
-    f1('push', a, [x], deopt + 0);
-  }
+var ceil = Math.ceil;
+function GetMathPi() {
+  return ceil(Math.PI * Math.PI);
+}
 
-  function foo() { return bar(arguments[0], arguments[1]); }
-  function baz(deopt) { return foo("x", deopt); }
+assertEquals(GetMathPi(), 10);
+GetMathPi();
 
-  baz(0);
-  baz(0);
-  %OptimizeFunctionOnNextCall(baz);
-  baz("deopt");
-})();
+%OptimizeFunctionOnNextCall(GetMathPi);
+
+assertEquals(GetMathPi(), 10);
+assertEquals(GetMathPi(), 10);
 
 
-(function DeoptimizeArgCallFunctionRuntime() {
-  var a = [];
 
-  var f1;
+new Function("Math = {PI: 1}")();
 
-  f1 = function(method, array, elem, deopt) {
-    assertEquals('push', method);
-  }
+assertEquals(GetMathPi(), 1);
+assertEquals(GetMathPi(), 1);
 
-  function bar(x, deopt) {
-    %_CallFunction(null, 'push', [x][0], ((deopt + 0), 1), f1);
-  }
+%OptimizeFunctionOnNextCall(GetMathPi);
 
-  function foo() { return bar(arguments[0], arguments[1]); }
-  function baz(deopt) { return foo(0, deopt); }
-
-  baz(0);
-  baz(0);
-  %OptimizeFunctionOnNextCall(baz);
-  baz("deopt");
-})();
+assertEquals(GetMathPi(), 1);
+assertEquals(GetMathPi(), 1);