Revert of Moving ArraySplice Builtin to ElementsAccessor

test/mjsunit/array-natives-elements.js

 // 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
@@ skipping 12 matching lines @@
 // 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
 
 // IC and Crankshaft support for smi-only elements in dynamic array literals.
 function get(foo) { return foo; }  // Used to generate dynamic values.
 
-function array_natives_test(optimized) {
+function array_natives_test() {
 
   // Ensure small array literals start in specific element kind mode.
   assertTrue(%HasFastSmiElements([]));
   assertTrue(%HasFastSmiElements([1]));
   assertTrue(%HasFastSmiElements([1,2]));
   assertTrue(%HasFastDoubleElements([1.1]));
   assertTrue(%HasFastDoubleElements([1.1,2]));
 
   // This code exists to eliminate the learning influence of AllocationSites
   // on the following tests.
@@ skipping 100 matching lines @@
   assertTrue(%HasFastSmiElements(a3r));
   assertTrue(%HasFastSmiElements(a3));
   assertEquals([], a3r);
   assertEquals([2, 1, 2, 3], a3);
   a3 = [1,2,3];
   a3r = a3.splice(0, 1, 2);
   assertTrue(%HasFastSmiElements(a3r));
   assertTrue(%HasFastSmiElements(a3));
   assertEquals([1], a3r);
   assertEquals([2, 2, 3], a3);
+
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 0);
   assertTrue(%HasFastDoubleElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([], a3r);
   assertEquals([1.1, 2, 3], a3);
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 1);
   assertTrue(%HasFastDoubleElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([1.1], a3r);
   assertEquals([2, 3], a3);
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 0, 2);
-  assertTrue(%HasFastDoubleElements(a3r));
+  // Commented out since handled in js, which takes the best fit.
+  // assertTrue(%HasFastDoubleElements(a3r));
+  assertTrue(%HasFastSmiElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([], a3r);
   assertEquals([2, 1.1, 2, 3], a3);
   a3 = [1.1,2,3];
-  assertTrue(%HasFastDoubleElements(a3));
   a3r = a3.splice(0, 1, 2);
   assertTrue(%HasFastDoubleElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([1.1], a3r);
   assertEquals([2, 2, 3], a3);
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 0, 2.1);
-  assertTrue(%HasFastDoubleElements(a3r));
+  // Commented out since handled in js, which takes the best fit.
+  // assertTrue(%HasFastDoubleElements(a3r));
+  assertTrue(%HasFastSmiElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([], a3r);
   assertEquals([2.1, 1.1, 2, 3], a3);
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 1, 2.2);
   assertTrue(%HasFastDoubleElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([1.1], a3r);
   assertEquals([2.2, 2, 3], a3);
   a3 = [1,2,3];
   a3r = a3.splice(0, 0, 2.1);
-  assertTrue(%HasFastDoubleElements(a3r));
+  // Commented out since handled in js, which takes the best fit.
+  // assertTrue(%HasFastDoubleElements(a3r));
+  assertTrue(%HasFastSmiElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([], a3r);
   assertEquals([2.1, 1, 2, 3], a3);
   a3 = [1,2,3];
   a3r = a3.splice(0, 1, 2.2);
   assertTrue(%HasFastDoubleElements(a3r));
   assertTrue(%HasFastDoubleElements(a3));
   assertEquals([1], a3r);
   assertEquals([2.2, 2, 3], a3);
+
   a3 = [{},2,3];
   a3r = a3.splice(0, 0);
   assertTrue(%HasFastObjectElements(a3r));
   assertTrue(%HasFastObjectElements(a3));
   assertEquals([], a3r);
   assertEquals([{}, 2, 3], a3);
   a3 = [1,2,{}];
   a3r = a3.splice(0, 1);
   assertTrue(%HasFastObjectElements(a3r));
   assertTrue(%HasFastObjectElements(a3));
   assertEquals([1], a3r);
   assertEquals([2, {}], a3);
   a3 = [1,2,3];
   a3r = a3.splice(0, 0, {});
   assertTrue(%HasFastObjectElements(a3r));
   assertTrue(%HasFastObjectElements(a3));
   assertEquals([], a3r);
   assertEquals([{}, 1, 2, 3], a3);
   a3 = [1,2,3];
   a3r = a3.splice(0, 1, {});
   assertTrue(%HasFastObjectElements(a3r));
   assertTrue(%HasFastObjectElements(a3));
   assertEquals([1], a3r);
   assertEquals([{}, 2, 3], a3);
+
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 0, {});
   assertTrue(%HasFastObjectElements(a3r));
   assertTrue(%HasFastObjectElements(a3));
   assertEquals([], a3r);
   assertEquals([{}, 1.1, 2, 3], a3);
   a3 = [1.1,2,3];
   a3r = a3.splice(0, 1, {});
   assertTrue(%HasFastObjectElements(a3r));
   assertTrue(%HasFastObjectElements(a3));
   assertEquals([1.1], a3r);
   assertEquals([{}, 2, 3], a3);
-  a3 = [1.1, 2.2, 3.3];
-  a3r = a3.splice(2, 1);
-  assertTrue(%HasFastDoubleElements(a3r));
-  assertTrue(%HasFastDoubleElements(a3));
-  assertEquals([3.3], a3r);
-  //assertTrue(%HasFastDoubleElements(a3r));
-  assertEquals([1.1, 2.2], a3);
-  //assertTrue(%HasFastDoubleElements(a3r));
-  a3r = a3.splice(1, 1, 4.4, 5.5);
-  //assertTrue(%HasFastDoubleElements(a3r));
-  //assertTrue(%HasFastDoubleElements(a3));
-  assertEquals([2.2], a3r);
-  assertEquals([1.1, 4.4, 5.5], a3);
 
   // Pop
   var a4 = [1,2,3];
   assertEquals(3, a4.pop());
   assertTrue(%HasFastSmiElements(a4));
   a4 = [1.1,2,3];
   assertEquals(3, a4.pop());
   assertTrue(%HasFastDoubleElements(a4));
   a4 = [{},2,3];
   assertEquals(3, a4.pop());
@@ skipping 27 matching lines @@
   a4.unshift(1);
   assertTrue(%HasFastObjectElements(a4));
   assertEquals([1,{},2,3], a4);
   a4 = [{},2,3];
   a4.unshift(1.1);
   assertTrue(%HasFastObjectElements(a4));
   assertEquals([1.1,{},2,3], a4);
 }
 
 for (var i = 0; i < 3; i++) {
-  array_natives_test(false);
+  array_natives_test();
 }
 %OptimizeFunctionOnNextCall(array_natives_test);
-array_natives_test(true);
+array_natives_test();