test262/implementation-contributed/v8/mjsunit/const-field-tracking.js

// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Flags: --allow-natives-syntax --opt --no-always-opt

var global = this;

// TODO(ishell): update the test once const->mutable migration does not
// create a new map.
var IS_INPLACE_MAP_MODIFICATION_SUPPORTED = false;

var unique_id = 0;
// Creates a function with unique SharedFunctionInfo to ensure the feedback
// vector is unique for each test case.
function MakeFunctionWithUniqueSFI(...args) {
  assertTrue(args.length > 0);
  var body = `/* Unique comment: ${unique_id++} */ ` + args.pop();
  return new Function(...args, body);
}


//
// Load constant field from constant object directly.
//
function TestLoadFromConstantFieldOfAConstantObject(the_value, other_value) {
  function A(v) { this.v = v; }
  function O() { this.a = new A(the_value); }
  var the_object = new O();

  // Ensure that {the_object.a}'s map is not stable to complicate compiler's
  // life.
  new A(the_value).blah = 0;

  // Ensure that constant tracking is enabled for {contant_object}.
  delete global.constant_object;
  global.constant_object = the_object;
  assertEquals(the_object, constant_object);

  assertTrue(%HasFastProperties(the_object));

  // {constant_object} is known to the compiler via global property cell
  // tracking.
  var load = MakeFunctionWithUniqueSFI("return constant_object.a.v;");
  load();
  load();
  %OptimizeFunctionOnNextCall(load);
  assertEquals(the_value, load());
  assertOptimized(load);
  if (IS_INPLACE_MAP_MODIFICATION_SUPPORTED) {
    var a = new A(other_value);
    assertTrue(%HaveSameMap(a, the_object.a));
    // Make constant field mutable by assigning another value
    // to some other instance of A.
    new A(the_value).v = other_value;
    assertTrue(%HaveSameMap(a, new A(the_value)));
    assertTrue(%HaveSameMap(a, the_object.a));
    assertUnoptimized(load);
    assertEquals(the_value, load());
  } else {
    var a = new A(other_value);
    assertTrue(%HaveSameMap(a, the_object.a));
    // Make constant field mutable by assigning another value
    // to some other instance of A.
    new A(the_value).v = other_value;
    assertOptimized(load);
    assertTrue(!%HaveSameMap(a, new A(the_value)));

    assertTrue(%HaveSameMap(a, the_object.a));
    // Ensure the {the_object.a} migrated to an up-to date version of a map
    // by loading a property through IC.
    assertEquals(the_value, the_object.a.v);
    assertTrue(!%HaveSameMap(a, the_object.a));
    assertOptimized(load);

    // Now attempt to call load should deoptimize because of failed map check.
    assertEquals(the_value, load());
  }
  assertUnoptimized(load);
  assertEquals(the_value, load());
}

// Test constant tracking with Smi value.
(function() {
  var the_value = 42;
  var other_value = 153;
  TestLoadFromConstantFieldOfAConstantObject(the_value, other_value);
})();

// Test constant tracking with double value.
(function() {
  var the_value = 0.9;
  var other_value = 0.42;
  TestLoadFromConstantFieldOfAConstantObject(the_value, other_value);
})();

// Test constant tracking with function value.
(function() {
  var the_value = function V() {};
  var other_value = function W() {};
  TestLoadFromConstantFieldOfAConstantObject(the_value, other_value);
})();

// Test constant tracking with heap object value.
(function() {
  function V() {}
  var the_value = new V();
  var other_value = new V();
  TestLoadFromConstantFieldOfAConstantObject(the_value, other_value);
})();


//
// Load constant field from a prototype.
//
function TestLoadFromConstantFieldOfAPrototype(the_value, other_value) {
  function Proto() { this.v = the_value; }
  var the_prototype = new Proto();

  function O() {}
  O.prototype = the_prototype;
  var the_object = new O();

  // Ensure O.prototype is in fast mode by loading from its field.
  function warmup() { return new O().v; }
  warmup(); warmup(); warmup();
  assertTrue(%HasFastProperties(O.prototype));

  // The parameter object is not constant but all the values have the same
  // map and therefore the compiler knows the prototype object and can
  // optimize load of "v".
  var load = MakeFunctionWithUniqueSFI("o", "return o.v;");
  load(new O());
  load(new O());
  %OptimizeFunctionOnNextCall(load);
  assertEquals(the_value, load(new O()));
  assertOptimized(load);
  if (IS_INPLACE_MAP_MODIFICATION_SUPPORTED) {
    // Invalidation of mutability should trigger deoptimization with a
    // "field-owner" reason.
    the_prototype.v = other_value;
  } else {
    // Invalidation of mutability should trigger deoptimization with a
    // "prototype-check" (stability) reason.
    the_prototype.v = other_value;
  }
  assertUnoptimized(load);
}

// Test constant tracking with Smi value.
(function() {
  var the_value = 42;
  var other_value = 153;
  TestLoadFromConstantFieldOfAPrototype(the_value, other_value);
})();

// Test constant tracking with double value.
(function() {
  var the_value = 0.9;
  var other_value = 0.42;
  TestLoadFromConstantFieldOfAPrototype(the_value, other_value);
})();

// Test constant tracking with function value.
(function() {
  var the_value = function V() {};
  var other_value = function W() {};
  TestLoadFromConstantFieldOfAPrototype(the_value, other_value);
})();

// Test constant tracking with heap object value.
(function() {
  function V() {}
  var the_value = new V();
  var other_value = new V();
  TestLoadFromConstantFieldOfAPrototype(the_value, other_value);
})();


//
// Store to constant field of a constant object.
//
function TestStoreToConstantFieldOfConstantObject(the_value, other_value) {
  function A(v) { this.v = v; }
  function O() { this.a = new A(the_value); }
  var the_object = new O();

  // Ensure that {the_object.a}'s map is not stable to complicate compiler's
  // life.
  new A(the_value).blah = 0;

  // Ensure that constant tracking is enabled for {contant_object}.
  delete global.constant_object;
  global.constant_object = the_object;
  assertEquals(the_object, constant_object);

  assertTrue(%HasFastProperties(the_object));

  // {constant_object} is known to the compiler via global property cell
  // tracking.
  var store = MakeFunctionWithUniqueSFI("v", "constant_object.a.v = v;");
  store(the_value);
  store(the_value);
  %OptimizeFunctionOnNextCall(store);
  store(the_value);
  assertEquals(the_value, constant_object.a.v);
  assertOptimized(store);
  // Storing of the same value does not deoptimize.
  store(the_value);
  assertEquals(the_value, constant_object.a.v);
  assertOptimized(store);

  if (IS_INPLACE_MAP_MODIFICATION_SUPPORTED) {
    var a = new A(other_value);

    if (typeof the_value == "function" || typeof the_value == "object") {
      // For heap object fields "field-owner" dependency is installed for
      // any access of the field, therefore making constant field mutable by
      // assigning other value to some other instance of A should already
      // trigger deoptimization.
      assertTrue(%HaveSameMap(a, the_object.a));
      new A(the_value).v = other_value;
      assertTrue(%HaveSameMap(a, new A(the_value)));
      assertTrue(%HaveSameMap(a, the_object.a));
      assertUnoptimized(store);
    } else {
      assertOptimized(store);
    }
    // Storing other value deoptimizes because of failed value check.
    store(other_value);
    assertUnoptimized(store);
    assertEquals(other_value, constant_object.a.v);
  } else {
    // Storing other value deoptimizes because of failed value check.
    store(other_value);
    assertUnoptimized(store);
    assertEquals(other_value, constant_object.a.v);
  }
}

// Test constant tracking with Smi values.
(function() {
  var the_value = 42;
  var other_value = 153;
  TestStoreToConstantFieldOfConstantObject(the_value, other_value);
})();

// Test constant tracking with double values.
(function() {
  var the_value = 0.9;
  var other_value = 0.42
  TestStoreToConstantFieldOfConstantObject(the_value, other_value);
})();

// Test constant tracking with function values.
(function() {
  var the_value = function V() {};
  var other_value = function W() {};
  TestStoreToConstantFieldOfConstantObject(the_value, other_value);
})();

// Test constant tracking with heap object values.
(function() {
  function V() {}
  var the_value = new V();
  var other_value = new V();
  TestStoreToConstantFieldOfConstantObject(the_value, other_value);
})();