mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 lines
18 KiB
551 lines
18 KiB
// Copyright 2012 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.
|
|
|
|
// Test dictionary -> double elements -> dictionary elements round trip
|
|
|
|
// Flags: --allow-natives-syntax --unbox-double-arrays --expose-gc
|
|
|
|
var large_array_size = 100000;
|
|
var approx_dict_to_elements_threshold = 70000;
|
|
|
|
var name = 0;
|
|
|
|
function expected_array_value(i) {
|
|
if ((i % 50) != 0) {
|
|
return i;
|
|
} else {
|
|
return i + 0.5;
|
|
}
|
|
}
|
|
|
|
function force_to_fast_double_array(a) {
|
|
a[large_array_size - 2] = 1;
|
|
for (var i= 0; i < approx_dict_to_elements_threshold; ++i ) {
|
|
a[i] = expected_array_value(i);
|
|
}
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function make_object_like_array(size) {
|
|
obj = new Object();
|
|
obj.length = size;
|
|
return obj;
|
|
}
|
|
|
|
function testOneArrayType(allocator) {
|
|
var large_array = new allocator(large_array_size);
|
|
force_to_fast_double_array(large_array);
|
|
var six = 6;
|
|
|
|
for (var i= 0; i < approx_dict_to_elements_threshold; i += 501 ) {
|
|
assertEquals(expected_array_value(i), large_array[i]);
|
|
}
|
|
|
|
// This function has a constant and won't get inlined.
|
|
function computed_6() {
|
|
return six;
|
|
}
|
|
|
|
// Multiple versions of the test function makes sure that IC/Crankshaft state
|
|
// doesn't get reused.
|
|
function test_various_loads(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
assertEquals(value_5, a[5]);
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_loads2(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
assertEquals(value_5, a[5]);
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_loads3(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
assertEquals(value_5, a[5]);
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_loads4(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
assertEquals(value_5, a[5]);
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_loads5(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
if (value_5 != undefined) {
|
|
assertEquals(value_5, a[5]);
|
|
};
|
|
if (value_6 != undefined) {
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
}
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_loads6(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
assertEquals(value_5, a[5]);
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_loads7(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
assertEquals(value_5, a[5]);
|
|
assertEquals(value_6, a[6]);
|
|
assertEquals(value_6, a[computed_6()]); // Test non-constant key
|
|
assertEquals(value_7, a[7]);
|
|
assertEquals(large_array_size, a.length);
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
function test_various_stores(a, value_5, value_6, value_7) {
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
a[5] = value_5;
|
|
a[computed_6()] = value_6;
|
|
a[7] = value_7;
|
|
assertTrue(%HasFastDoubleElements(a));
|
|
}
|
|
|
|
// Test double and integer values
|
|
test_various_loads(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
test_various_loads(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
test_various_loads(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
%OptimizeFunctionOnNextCall(test_various_loads);
|
|
test_various_loads(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
// Test NaN values
|
|
test_various_stores(large_array, NaN, -NaN, expected_array_value(7));
|
|
|
|
test_various_loads2(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
test_various_loads2(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
test_various_loads2(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
%OptimizeFunctionOnNextCall(test_various_loads2);
|
|
test_various_loads2(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
|
|
// Test Infinity values
|
|
test_various_stores(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
|
|
test_various_loads3(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
test_various_loads3(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
test_various_loads3(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
%OptimizeFunctionOnNextCall(test_various_loads3);
|
|
test_various_loads3(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
|
|
// Test the hole for the default runtime implementation.
|
|
delete large_array[5];
|
|
delete large_array[6];
|
|
test_various_loads4(large_array,
|
|
undefined,
|
|
undefined,
|
|
expected_array_value(7));
|
|
|
|
// Test the keyed load IC implementation when the value is the hole.
|
|
test_various_stores(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
test_various_loads5(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
test_various_loads5(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
delete large_array[5];
|
|
delete large_array[6];
|
|
test_various_loads5(large_array,
|
|
undefined,
|
|
undefined,
|
|
expected_array_value(7));
|
|
test_various_loads5(large_array,
|
|
undefined,
|
|
undefined,
|
|
expected_array_value(7));
|
|
|
|
// Make sure Crankshaft code handles the hole correctly (bailout)
|
|
var large_array = new allocator(large_array_size);
|
|
force_to_fast_double_array(large_array);
|
|
test_various_stores(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
test_various_loads6(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
test_various_loads6(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
%OptimizeFunctionOnNextCall(test_various_loads6);
|
|
test_various_loads6(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
delete large_array[5];
|
|
delete large_array[6];
|
|
test_various_loads6(large_array,
|
|
undefined,
|
|
undefined,
|
|
expected_array_value(7));
|
|
|
|
%DeoptimizeFunction(test_various_loads6);
|
|
%ClearFunctionTypeFeedback(test_various_stores);
|
|
%ClearFunctionTypeFeedback(test_various_loads7);
|
|
|
|
// Test stores for non-NaN.
|
|
var large_array = new allocator(large_array_size);
|
|
force_to_fast_double_array(large_array);
|
|
%OptimizeFunctionOnNextCall(test_various_stores);
|
|
test_various_stores(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
test_various_stores(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
test_various_loads7(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
test_various_loads7(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
%OptimizeFunctionOnNextCall(test_various_loads7);
|
|
|
|
test_various_loads7(large_array,
|
|
expected_array_value(5),
|
|
expected_array_value(6),
|
|
expected_array_value(7));
|
|
|
|
// Test NaN behavior for stores.
|
|
test_various_stores(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
|
|
test_various_stores(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
|
|
test_various_loads7(large_array,
|
|
NaN,
|
|
-NaN,
|
|
expected_array_value(7));
|
|
|
|
// Test Infinity behavior for stores.
|
|
test_various_stores(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
|
|
test_various_stores(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
|
|
test_various_loads7(large_array,
|
|
Infinity,
|
|
-Infinity,
|
|
expected_array_value(7));
|
|
|
|
assertOptimized(test_various_stores);
|
|
|
|
// Make sure that we haven't converted from fast double.
|
|
assertTrue(%HasFastDoubleElements(large_array));
|
|
}
|
|
|
|
// Force gc here to start with a clean heap if we repeat this test multiple
|
|
// times.
|
|
gc();
|
|
testOneArrayType(make_object_like_array);
|
|
testOneArrayType(Array);
|
|
|
|
var large_array = new Array(large_array_size);
|
|
force_to_fast_double_array(large_array);
|
|
assertTrue(%HasFastDoubleElements(large_array));
|
|
|
|
// Cause the array to grow beyond it's JSArray length. This will double the
|
|
// size of the capacity and force the array into "slow" dictionary case.
|
|
large_array[5] = Infinity;
|
|
large_array[large_array_size+10001] = 50;
|
|
assertTrue(%HasDictionaryElements(large_array));
|
|
assertEquals(50, large_array[large_array_size+10001]);
|
|
assertEquals(large_array_size+10002, large_array.length);
|
|
assertEquals(Infinity, large_array[5]);
|
|
assertEquals(undefined, large_array[large_array_size-1]);
|
|
assertEquals(undefined, large_array[-1]);
|
|
assertEquals(large_array_size+10002, large_array.length);
|
|
|
|
// Test dictionary -> double elements -> fast elements.
|
|
var large_array2 = new Array(large_array_size);
|
|
force_to_fast_double_array(large_array2);
|
|
delete large_array2[5];
|
|
|
|
// Convert back to fast elements and make sure the contents of the array are
|
|
// unchanged.
|
|
large_array2[25] = new Object();
|
|
assertTrue(%HasFastObjectElements(large_array2));
|
|
for (var i= 0; i < approx_dict_to_elements_threshold; i += 500 ) {
|
|
if (i != 25 && i != 5) {
|
|
assertEquals(expected_array_value(i), large_array2[i]);
|
|
}
|
|
}
|
|
assertEquals(undefined, large_array2[5]);
|
|
assertEquals(undefined, large_array2[large_array_size-1]);
|
|
assertEquals(undefined, large_array2[-1]);
|
|
assertEquals(large_array_size, large_array2.length);
|
|
|
|
// Make sure it's possible to change the array's length and that array is still
|
|
// intact after the resize.
|
|
var large_array3 = new Array(large_array_size);
|
|
force_to_fast_double_array(large_array3);
|
|
large_array3.length = 60000;
|
|
assertEquals(60000, large_array3.length);
|
|
assertEquals(undefined, large_array3[60000]);
|
|
assertTrue(%HasFastDoubleElements(large_array3));
|
|
assertEquals(expected_array_value(5), large_array3[5]);
|
|
assertEquals(expected_array_value(6), large_array3[6]);
|
|
assertEquals(expected_array_value(7), large_array3[7]);
|
|
assertEquals(expected_array_value(large_array3.length-1),
|
|
large_array3[large_array3.length-1]);
|
|
assertEquals(undefined, large_array3[large_array_size-1]);
|
|
assertEquals(undefined, large_array3[-1]);
|
|
gc();
|
|
|
|
for (var i= 0; i < large_array3.length; i += 501 ) {
|
|
assertEquals(expected_array_value(i), large_array3[i]);
|
|
}
|
|
|
|
large_array3.length = 25;
|
|
assertEquals(25, large_array3.length);
|
|
assertTrue(%HasFastDoubleElements(large_array3));
|
|
assertEquals(undefined, large_array3[25]);
|
|
assertEquals(expected_array_value(5), large_array3[5]);
|
|
assertEquals(expected_array_value(6), large_array3[6]);
|
|
assertEquals(expected_array_value(7), large_array3[7]);
|
|
assertEquals(expected_array_value(large_array3.length-1),
|
|
large_array3[large_array3.length-1]);
|
|
assertEquals(undefined, large_array3[large_array_size-1]);
|
|
assertEquals(undefined, large_array3[-1]);
|
|
gc();
|
|
|
|
for (var i= 0; i < large_array3.length; ++i) {
|
|
assertEquals(expected_array_value(i), large_array3[i]);
|
|
}
|
|
|
|
large_array3.length = 100;
|
|
assertEquals(100, large_array3.length);
|
|
large_array3[95] = 95;
|
|
assertTrue(%HasFastDoubleElements(large_array3));
|
|
assertEquals(undefined, large_array3[100]);
|
|
assertEquals(95, large_array3[95]);
|
|
assertEquals(expected_array_value(5), large_array3[5]);
|
|
assertEquals(expected_array_value(6), large_array3[6]);
|
|
assertEquals(expected_array_value(7), large_array3[7]);
|
|
assertEquals(undefined, large_array3[large_array3.length-1]);
|
|
assertEquals(undefined, large_array3[large_array_size-1]);
|
|
assertEquals(undefined, large_array3[-1]);
|
|
gc();
|
|
|
|
// Test apply on arrays backed by double elements.
|
|
function called_by_apply(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
assertEquals(expected_array_value(0), arg0);
|
|
assertEquals(NaN, arg1);
|
|
assertEquals(-NaN, arg2);
|
|
assertEquals(Infinity, arg3);
|
|
assertEquals(-Infinity, arg4);
|
|
assertEquals(expected_array_value(5), arg5);
|
|
}
|
|
|
|
large_array3[1] = NaN;
|
|
large_array3[2] = -NaN;
|
|
large_array3[3] = Infinity;
|
|
large_array3[4] = -Infinity;
|
|
|
|
function call_apply() {
|
|
called_by_apply.apply({}, large_array3);
|
|
}
|
|
|
|
call_apply();
|
|
call_apply();
|
|
call_apply();
|
|
%OptimizeFunctionOnNextCall(call_apply);
|
|
call_apply();
|
|
call_apply();
|
|
call_apply();
|
|
|
|
function test_for_in() {
|
|
// Due to previous tests, keys 0..25 and 95 should be present.
|
|
next_expected = 0;
|
|
for (x in large_array3) {
|
|
assertTrue(next_expected++ == x);
|
|
if (next_expected == 25) {
|
|
next_expected = 95;
|
|
}
|
|
}
|
|
assertTrue(next_expected == 96);
|
|
}
|
|
|
|
test_for_in();
|
|
test_for_in();
|
|
test_for_in();
|
|
%OptimizeFunctionOnNextCall(test_for_in);
|
|
test_for_in();
|
|
test_for_in();
|
|
test_for_in();
|
|
|
|
function test_get_property_names() {
|
|
names = %GetPropertyNames(large_array3);
|
|
property_name_count = 0;
|
|
for (x in names) { property_name_count++; };
|
|
assertEquals(26, property_name_count);
|
|
}
|
|
|
|
test_get_property_names();
|
|
test_get_property_names();
|
|
test_get_property_names();
|
|
|
|
// Test elements getters.
|
|
assertEquals(expected_array_value(10), large_array3[10]);
|
|
assertEquals(expected_array_value(-NaN), large_array3[2]);
|
|
large_array3.__defineGetter__("2", function(){
|
|
return expected_array_value(10);
|
|
});
|
|
|
|
function test_getter() {
|
|
assertEquals(expected_array_value(10), large_array3[10]);
|
|
assertEquals(expected_array_value(10), large_array3[2]);
|
|
}
|
|
|
|
test_getter();
|
|
test_getter();
|
|
test_getter();
|
|
%OptimizeFunctionOnNextCall(test_getter);
|
|
test_getter();
|
|
test_getter();
|
|
test_getter();
|
|
|
|
// Test element setters.
|
|
large_array4 = new Array(large_array_size);
|
|
force_to_fast_double_array(large_array4);
|
|
|
|
var setter_called = false;
|
|
|
|
assertEquals(expected_array_value(10), large_array4[10]);
|
|
assertEquals(expected_array_value(2), large_array4[2]);
|
|
large_array4.__defineSetter__("10", function(value){
|
|
setter_called = true;
|
|
});
|
|
|
|
function test_setter() {
|
|
setter_called = false;
|
|
large_array4[10] = 119;
|
|
assertTrue(setter_called);
|
|
assertEquals(undefined, large_array4[10]);
|
|
assertEquals(expected_array_value(2), large_array4[2]);
|
|
}
|
|
|
|
test_setter();
|
|
test_setter();
|
|
test_setter();
|
|
%OptimizeFunctionOnNextCall(test_setter);
|
|
test_setter();
|
|
test_setter();
|
|
test_setter();
|
|
|