src/v8/test/mjsunit/array-natives-elements.js

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 // Flags: --allow-natives-syntax --smi-only-arrays
  29
  30 // Test element kind of objects.
  31 // Since --smi-only-arrays affects builtins, its default setting at compile time
  32 // sticks if built with snapshot. If --smi-only-arrays is deactivated by
  33 // default, only a no-snapshot build actually has smi-only arrays enabled in
  34 // this test case. Depending on whether smi-only arrays are actually enabled,
  35 // this test takes the appropriate code path to check smi-only arrays.
  36
  37 support_smi_only_arrays = %HasFastSmiElements([1,2,3,4,5,6,7,8,9,10]);
  38
  39 if (support_smi_only_arrays) {
  40   print("Tests include smi-only arrays.");
  41 } else {
  42   print("Tests do NOT include smi-only arrays.");
  43 }
  44
  45 // IC and Crankshaft support for smi-only elements in dynamic array literals.
  46 function get(foo) { return foo; }  // Used to generate dynamic values.
  47
  48 function array_natives_test() {
  49
  50   // Ensure small array literals start in specific element kind mode.
  51   assertTrue(%HasFastSmiElements([]));
  52   assertTrue(%HasFastSmiElements([1]));
  53   assertTrue(%HasFastSmiElements([1,2]));
  54   assertTrue(%HasFastDoubleElements([1.1]));
  55   assertTrue(%HasFastDoubleElements([1.1,2]));
  56
  57   // Push
  58   var a0 = [1, 2, 3];
  59   if (%HasFastSmiElements(a0)) {
  60     assertTrue(%HasFastSmiElements(a0));
  61     a0.push(4);
  62     assertTrue(%HasFastSmiElements(a0));
  63     a0.push(1.3);
  64     assertTrue(%HasFastDoubleElements(a0));
  65     a0.push(1.5);
  66     assertTrue(%HasFastDoubleElements(a0));
  67     a0.push({});
  68     assertTrue(%HasFastObjectElements(a0));
  69     a0.push({});
  70     assertTrue(%HasFastObjectElements(a0));
  71   } else {
  72     assertTrue(%HasFastObjectElements(a0));
  73     a0.push(4);
  74     a0.push(1.3);
  75     a0.push(1.5);
  76     a0.push({});
  77     a0.push({});
  78     assertTrue(%HasFastObjectElements(a0));
  79   }
  80   assertEquals([1,2,3,4,1.3,1.5,{},{}], a0);
  81
  82   // Concat
  83   var a1;
  84   a1 = [1,2,3].concat([]);
  85   assertTrue(%HasFastSmiElements(a1));
  86   assertEquals([1,2,3], a1);
  87   a1 = [1,2,3].concat([4,5,6]);
  88   assertTrue(%HasFastSmiElements(a1));
  89   assertEquals([1,2,3,4,5,6], a1);
  90   a1 = [1,2,3].concat([4,5,6], [7,8,9]);
  91   assertTrue(%HasFastSmiElements(a1));
  92   assertEquals([1,2,3,4,5,6,7,8,9], a1);
  93   a1 = [1.1,2,3].concat([]);
  94   assertTrue(%HasFastDoubleElements(a1));
  95   assertEquals([1.1,2,3], a1);
  96   a1 = [1,2,3].concat([1.1, 2]);
  97   assertTrue(%HasFastDoubleElements(a1));
  98   assertEquals([1,2,3,1.1,2], a1);
  99   a1 = [1.1,2,3].concat([1, 2]);
 100   assertTrue(%HasFastDoubleElements(a1));
 101   assertEquals([1.1,2,3,1,2], a1);
 102   a1 = [1.1,2,3].concat([1.2, 2]);
 103   assertTrue(%HasFastDoubleElements(a1));
 104   assertEquals([1.1,2,3,1.2,2], a1);
 105
 106   a1 = [1,2,3].concat([{}]);
 107   assertTrue(%HasFastObjectElements(a1));
 108   assertEquals([1,2,3,{}], a1);
 109   a1 = [1.1,2,3].concat([{}]);
 110   assertTrue(%HasFastObjectElements(a1));
 111   assertEquals([1.1,2,3,{}], a1);
 112   a1 = [{}].concat([1,2,3]);
 113   assertTrue(%HasFastObjectElements(a1));
 114   assertEquals([{},1,2,3], a1);
 115   a1 = [{}].concat([1.1,2,3]);
 116   assertTrue(%HasFastObjectElements(a1));
 117   assertEquals([{},1.1,2,3], a1);
 118
 119   // Slice
 120   var a2 = [1,2,3];
 121   assertTrue(%HasFastSmiElements(a2.slice()));
 122   assertTrue(%HasFastSmiElements(a2.slice(1)));
 123   assertTrue(%HasFastSmiElements(a2.slice(1, 2)));
 124   assertEquals([1,2,3], a2.slice());
 125   assertEquals([2,3], a2.slice(1));
 126   assertEquals([2], a2.slice(1,2));
 127   a2 = [1.1,2,3];
 128   assertTrue(%HasFastDoubleElements(a2.slice()));
 129   assertTrue(%HasFastDoubleElements(a2.slice(1)));
 130   assertTrue(%HasFastDoubleElements(a2.slice(1, 2)));
 131   assertEquals([1.1,2,3], a2.slice());
 132   assertEquals([2,3], a2.slice(1));
 133   assertEquals([2], a2.slice(1,2));
 134   a2 = [{},2,3];
 135   assertTrue(%HasFastObjectElements(a2.slice()));
 136   assertTrue(%HasFastObjectElements(a2.slice(1)));
 137   assertTrue(%HasFastObjectElements(a2.slice(1, 2)));
 138   assertEquals([{},2,3], a2.slice());
 139   assertEquals([2,3], a2.slice(1));
 140   assertEquals([2], a2.slice(1,2));
 141
 142   // Splice
 143   var a3 = [1,2,3];
 144   var a3r;
 145   a3r = a3.splice(0, 0);
 146   assertTrue(%HasFastSmiElements(a3r));
 147   assertTrue(%HasFastSmiElements(a3));
 148   assertEquals([], a3r);
 149   assertEquals([1, 2, 3], a3);
 150   a3 = [1,2,3];
 151   a3r = a3.splice(0, 1);
 152   assertTrue(%HasFastSmiElements(a3r));
 153   assertTrue(%HasFastSmiElements(a3));
 154   assertEquals([1], a3r);
 155   assertEquals([2, 3], a3);
 156   a3 = [1,2,3];
 157   a3r = a3.splice(0, 0, 2);
 158   assertTrue(%HasFastSmiElements(a3r));
 159   assertTrue(%HasFastSmiElements(a3));
 160   assertEquals([], a3r);
 161   assertEquals([2, 1, 2, 3], a3);
 162   a3 = [1,2,3];
 163   a3r = a3.splice(0, 1, 2);
 164   assertTrue(%HasFastSmiElements(a3r));
 165   assertTrue(%HasFastSmiElements(a3));
 166   assertEquals([1], a3r);
 167   assertEquals([2, 2, 3], a3);
 168
 169   a3 = [1.1,2,3];
 170   a3r = a3.splice(0, 0);
 171   assertTrue(%HasFastDoubleElements(a3r));
 172   assertTrue(%HasFastDoubleElements(a3));
 173   assertEquals([], a3r);
 174   assertEquals([1.1, 2, 3], a3);
 175   a3 = [1.1,2,3];
 176   a3r = a3.splice(0, 1);
 177   assertTrue(%HasFastDoubleElements(a3r));
 178   assertTrue(%HasFastDoubleElements(a3));
 179   assertEquals([1.1], a3r);
 180   assertEquals([2, 3], a3);
 181   a3 = [1.1,2,3];
 182   a3r = a3.splice(0, 0, 2);
 183   // Commented out since handled in js, which takes the best fit.
 184   // assertTrue(%HasFastDoubleElements(a3r));
 185   assertTrue(%HasFastSmiElements(a3r));
 186   assertTrue(%HasFastDoubleElements(a3));
 187   assertEquals([], a3r);
 188   assertEquals([2, 1.1, 2, 3], a3);
 189   a3 = [1.1,2,3];
 190   a3r = a3.splice(0, 1, 2);
 191   assertTrue(%HasFastDoubleElements(a3r));
 192   assertTrue(%HasFastDoubleElements(a3));
 193   assertEquals([1.1], a3r);
 194   assertEquals([2, 2, 3], a3);
 195   a3 = [1.1,2,3];
 196   a3r = a3.splice(0, 0, 2.1);
 197   // Commented out since handled in js, which takes the best fit.
 198   // assertTrue(%HasFastDoubleElements(a3r));
 199   assertTrue(%HasFastSmiElements(a3r));
 200   assertTrue(%HasFastDoubleElements(a3));
 201   assertEquals([], a3r);
 202   assertEquals([2.1, 1.1, 2, 3], a3);
 203   a3 = [1.1,2,3];
 204   a3r = a3.splice(0, 1, 2.2);
 205   assertTrue(%HasFastDoubleElements(a3r));
 206   assertTrue(%HasFastDoubleElements(a3));
 207   assertEquals([1.1], a3r);
 208   assertEquals([2.2, 2, 3], a3);
 209   a3 = [1,2,3];
 210   a3r = a3.splice(0, 0, 2.1);
 211   // Commented out since handled in js, which takes the best fit.
 212   // assertTrue(%HasFastDoubleElements(a3r));
 213   assertTrue(%HasFastSmiElements(a3r));
 214   assertTrue(%HasFastDoubleElements(a3));
 215   assertEquals([], a3r);
 216   assertEquals([2.1, 1, 2, 3], a3);
 217   a3 = [1,2,3];
 218   a3r = a3.splice(0, 1, 2.2);
 219   assertTrue(%HasFastDoubleElements(a3r));
 220   assertTrue(%HasFastDoubleElements(a3));
 221   assertEquals([1], a3r);
 222   assertEquals([2.2, 2, 3], a3);
 223
 224   a3 = [{},2,3];
 225   a3r = a3.splice(0, 0);
 226   assertTrue(%HasFastObjectElements(a3r));
 227   assertTrue(%HasFastObjectElements(a3));
 228   assertEquals([], a3r);
 229   assertEquals([{}, 2, 3], a3);
 230   a3 = [1,2,{}];
 231   a3r = a3.splice(0, 1);
 232   assertTrue(%HasFastObjectElements(a3r));
 233   assertTrue(%HasFastObjectElements(a3));
 234   assertEquals([1], a3r);
 235   assertEquals([2, {}], a3);
 236   a3 = [1,2,3];
 237   a3r = a3.splice(0, 0, {});
 238   assertTrue(%HasFastObjectElements(a3r));
 239   assertTrue(%HasFastObjectElements(a3));
 240   assertEquals([], a3r);
 241   assertEquals([{}, 1, 2, 3], a3);
 242   a3 = [1,2,3];
 243   a3r = a3.splice(0, 1, {});
 244   assertTrue(%HasFastObjectElements(a3r));
 245   assertTrue(%HasFastObjectElements(a3));
 246   assertEquals([1], a3r);
 247   assertEquals([{}, 2, 3], a3);
 248
 249   a3 = [1.1,2,3];
 250   a3r = a3.splice(0, 0, {});
 251   assertTrue(%HasFastObjectElements(a3r));
 252   assertTrue(%HasFastObjectElements(a3));
 253   assertEquals([], a3r);
 254   assertEquals([{}, 1.1, 2, 3], a3);
 255   a3 = [1.1,2,3];
 256   a3r = a3.splice(0, 1, {});
 257   assertTrue(%HasFastObjectElements(a3r));
 258   assertTrue(%HasFastObjectElements(a3));
 259   assertEquals([1.1], a3r);
 260   assertEquals([{}, 2, 3], a3);
 261
 262   // Pop
 263   var a4 = [1,2,3];
 264   assertEquals(3, a4.pop());
 265   assertTrue(%HasFastSmiElements(a4));
 266   a4 = [1.1,2,3];
 267   assertEquals(3, a4.pop());
 268   assertTrue(%HasFastDoubleElements(a4));
 269   a4 = [{},2,3];
 270   assertEquals(3, a4.pop());
 271   assertTrue(%HasFastObjectElements(a4));
 272
 273   // Shift
 274   var a4 = [1,2,3];
 275   assertEquals(1, a4.shift());
 276   assertTrue(%HasFastSmiElements(a4));
 277   a4 = [1.1,2,3];
 278   assertEquals(1.1, a4.shift());
 279   assertTrue(%HasFastDoubleElements(a4));
 280   a4 = [{},2,3];
 281   assertEquals({}, a4.shift());
 282   assertTrue(%HasFastObjectElements(a4));
 283
 284   // Unshift
 285   var a4 = [1,2,3];
 286   a4.unshift(1);
 287   assertTrue(%HasFastSmiElements(a4));
 288   assertEquals([1,1,2,3], a4);
 289   a4 = [1,2,3];
 290   a4.unshift(1.1);
 291   // TODO(verwaest): We'll want to support double unshifting as well.
 292   // assertTrue(%HasFastDoubleElements(a4));
 293   assertTrue(%HasFastObjectElements(a4));
 294   assertEquals([1.1,1,2,3], a4);
 295   a4 = [1.1,2,3];
 296   a4.unshift(1);
 297   // assertTrue(%HasFastDoubleElements(a4));
 298   assertTrue(%HasFastObjectElements(a4));
 299   assertEquals([1,1.1,2,3], a4);
 300   a4 = [{},2,3];
 301   a4.unshift(1);
 302   assertTrue(%HasFastObjectElements(a4));
 303   assertEquals([1,{},2,3], a4);
 304   a4 = [{},2,3];
 305   a4.unshift(1.1);
 306   assertTrue(%HasFastObjectElements(a4));
 307   assertEquals([1.1,{},2,3], a4);
 308 }
 309
 310 if (support_smi_only_arrays) {
 311   for (var i = 0; i < 3; i++) {
 312     array_natives_test();
 313   }
 314   %OptimizeFunctionOnNextCall(array_natives_test);
 315   array_natives_test();
 316 }