diff options
Diffstat (limited to 'deps/v8/test/mjsunit/array-feedback.js')
| -rw-r--r-- | deps/v8/test/mjsunit/array-feedback.js | 303 |
1 files changed, 148 insertions, 155 deletions
diff --git a/deps/v8/test/mjsunit/array-feedback.js b/deps/v8/test/mjsunit/array-feedback.js index 4129be1f8..ffbb49b19 100644 --- a/deps/v8/test/mjsunit/array-feedback.js +++ b/deps/v8/test/mjsunit/array-feedback.js @@ -25,25 +25,9 @@ // (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 --smi-only-arrays --expose-gc +// Flags: --allow-natives-syntax --expose-gc // Flags: --noalways-opt -// Test element kind of objects. -// Since --smi-only-arrays affects builtins, its default setting at compile -// time sticks if built with snapshot. If --smi-only-arrays is deactivated -// by default, only a no-snapshot build actually has smi-only arrays enabled -// in this test case. Depending on whether smi-only arrays are actually -// enabled, this test takes the appropriate code path to check smi-only arrays. - -// support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8)); -support_smi_only_arrays = true; - -if (support_smi_only_arrays) { - print("Tests include smi-only arrays."); -} else { - print("Tests do NOT include smi-only arrays."); -} - var elements_kind = { fast_smi_only : 'fast smi only elements', fast : 'fast elements', @@ -73,144 +57,153 @@ function isHoley(obj) { } function assertKind(expected, obj, name_opt) { - if (!support_smi_only_arrays && - expected == elements_kind.fast_smi_only) { - expected = elements_kind.fast; - } assertEquals(expected, getKind(obj), name_opt); } -if (support_smi_only_arrays) { - - // Verify that basic elements kind feedback works for non-constructor - // array calls (as long as the call is made through an IC, and not - // a CallStub). - // (function (){ - // function create0() { - // return Array(); - // } - - // // Calls through ICs need warm up through uninitialized, then - // // premonomorphic first. - // create0(); - // create0(); - // a = create0(); - // assertKind(elements_kind.fast_smi_only, a); - // a[0] = 3.5; - // b = create0(); - // assertKind(elements_kind.fast_double, b); - - // function create1(arg) { - // return Array(arg); - // } - - // create1(0); - // create1(0); - // a = create1(0); - // assertFalse(isHoley(a)); - // assertKind(elements_kind.fast_smi_only, a); - // a[0] = "hello"; - // b = create1(10); - // assertTrue(isHoley(b)); - // assertKind(elements_kind.fast, b); - - // a = create1(100000); - // assertKind(elements_kind.dictionary, a); - - // function create3(arg1, arg2, arg3) { - // return Array(arg1, arg2, arg3); - // } - - // create3(); - // create3(); - // a = create3(1,2,3); - // a[0] = 3.5; - // b = create3(1,2,3); - // assertKind(elements_kind.fast_double, b); - // assertFalse(isHoley(b)); - // })(); - - - // Verify that keyed calls work - // (function (){ - // function create0(name) { - // return this[name](); - // } - - // name = "Array"; - // create0(name); - // create0(name); - // a = create0(name); - // a[0] = 3.5; - // b = create0(name); - // assertKind(elements_kind.fast_double, b); - // })(); - - - // Verify that the IC can't be spoofed by patching - (function (){ - function create0() { - return Array(); - } - - create0(); - create0(); - a = create0(); - assertKind(elements_kind.fast_smi_only, a); - var oldArray = this.Array; - this.Array = function() { return ["hi"]; }; - b = create0(); - assertEquals(["hi"], b); - this.Array = oldArray; - })(); - - // Verify that calls are still made through an IC after crankshaft, - // though the type information is reset. - // TODO(mvstanton): instead, consume the type feedback gathered up - // until crankshaft time. - // (function (){ - // function create0() { - // return Array(); - // } - - // create0(); - // create0(); - // a = create0(); - // a[0] = 3.5; - // %OptimizeFunctionOnNextCall(create0); - // create0(); - // // This test only makes sense if crankshaft is allowed - // if (4 != %GetOptimizationStatus(create0)) { - // create0(); - // b = create0(); - // assertKind(elements_kind.fast_smi_only, b); - // b[0] = 3.5; - // c = create0(); - // assertKind(elements_kind.fast_double, c); - // assertOptimized(create0); - // } - // })(); - - - // Verify that cross context calls work - (function (){ - var realmA = Realm.current(); - var realmB = Realm.create(); - assertEquals(0, realmA); - assertEquals(1, realmB); - - function instanceof_check(type) { - assertTrue(type() instanceof type); - assertTrue(type(5) instanceof type); - assertTrue(type(1,2,3) instanceof type); - } - - var realmBArray = Realm.eval(realmB, "Array"); - instanceof_check(Array); - instanceof_check(Array); - instanceof_check(Array); - instanceof_check(realmBArray); - instanceof_check(realmBArray); - instanceof_check(realmBArray); - })(); -} +// Verify that basic elements kind feedback works for non-constructor +// array calls (as long as the call is made through an IC, and not +// a CallStub). +(function (){ + function create0() { + return Array(); + } + + // Calls through ICs need warm up through uninitialized, then + // premonomorphic first. + create0(); + a = create0(); + assertKind(elements_kind.fast_smi_only, a); + a[0] = 3.5; + b = create0(); + assertKind(elements_kind.fast_double, b); + + function create1(arg) { + return Array(arg); + } + + create1(0); + create1(0); + a = create1(0); + assertFalse(isHoley(a)); + assertKind(elements_kind.fast_smi_only, a); + a[0] = "hello"; + b = create1(10); + assertTrue(isHoley(b)); + assertKind(elements_kind.fast, b); + + a = create1(100000); + assertKind(elements_kind.fast_smi_only, a); + + function create3(arg1, arg2, arg3) { + return Array(arg1, arg2, arg3); + } + + create3(1,2,3); + create3(1,2,3); + a = create3(1,2,3); + a[0] = 3.035; + assertKind(elements_kind.fast_double, a); + b = create3(1,2,3); + assertKind(elements_kind.fast_double, b); + assertFalse(isHoley(b)); +})(); + + +// Verify that keyed calls work +(function (){ + function create0(name) { + return this[name](); + } + + name = "Array"; + create0(name); + create0(name); + a = create0(name); + a[0] = 3.5; + b = create0(name); + assertKind(elements_kind.fast_double, b); +})(); + + +// Verify that feedback is turned off if the call site goes megamorphic. +(function (){ + function foo(arg) { return arg(); } + foo(Array); + foo(function() {}); + foo(Array); + + gc(); + + a = foo(Array); + a[0] = 3.5; + b = foo(Array); + // b doesn't benefit from elements kind feedback at a megamorphic site. + assertKind(elements_kind.fast_smi_only, b); +})(); + + +// Verify that crankshaft consumes type feedback. +(function (){ + function create0() { + return Array(); + } + + create0(); + create0(); + a = create0(); + a[0] = 3.5; + %OptimizeFunctionOnNextCall(create0); + create0(); + create0(); + b = create0(); + assertKind(elements_kind.fast_double, b); + assertOptimized(create0); + + function create1(arg) { + return Array(arg); + } + + create1(8); + create1(8); + a = create1(8); + a[0] = 3.5; + %OptimizeFunctionOnNextCall(create1); + b = create1(8); + assertKind(elements_kind.fast_double, b); + assertOptimized(create1); + + function createN(arg1, arg2, arg3) { + return Array(arg1, arg2, arg3); + } + + createN(1, 2, 3); + createN(1, 2, 3); + a = createN(1, 2, 3); + a[0] = 3.5; + %OptimizeFunctionOnNextCall(createN); + b = createN(1, 2, 3); + assertKind(elements_kind.fast_double, b); + assertOptimized(createN); +})(); + +// Verify that cross context calls work +(function (){ + var realmA = Realm.current(); + var realmB = Realm.create(); + assertEquals(0, realmA); + assertEquals(1, realmB); + + function instanceof_check(type) { + assertTrue(type() instanceof type); + assertTrue(type(5) instanceof type); + assertTrue(type(1,2,3) instanceof type); + } + + var realmBArray = Realm.eval(realmB, "Array"); + instanceof_check(Array); + instanceof_check(Array); + instanceof_check(Array); + instanceof_check(realmBArray); + instanceof_check(realmBArray); + instanceof_check(realmBArray); +})(); |