libv8 3.11.8.17 → 3.16.14.0

data/vendor/v8/test/mjsunit/{fuzz-natives.js → fuzz-natives-part4.js}

@@ -147,8 +147,10 @@ var knownProblems = {
   "PushWithContext": true,
   "PushCatchContext": true,
   "PushBlockContext": true,
+  "PushModuleContext": true,
   "LazyCompile": true,
   "LazyRecompile": true,
+  "ParallelRecompile": true,
   "NotifyDeoptimized": true,
   "NotifyOSR": true,
   "CreateObjectLiteralBoilerplate": true,
@@ -194,7 +196,13 @@ var knownProblems = {
 
   // Only applicable to strings.
   "_HasCachedArrayIndex": true,
-  "_GetCachedArrayIndex": true
+  "_GetCachedArrayIndex": true,
+  "_OneByteSeqStringSetChar": true,
+  "_TwoByteSeqStringSetChar": true,
+
+  // Only for debugging parallel recompilation.
+  "InstallRecompiledCode": true,
+  "ForceParallelRecompile": true
 };
 
 var currentlyUncallable = {
@@ -204,7 +212,9 @@ var currentlyUncallable = {
 
 function testNatives() {
   var allNatives = %ListNatives();
-  for (var i = 0; i < allNatives.length; i++) {
+  var start = (allNatives.length >> 2)*3;
+  var stop = allNatives.length;
+  for (var i = start; i < stop; i++) {
     var nativeInfo = allNatives[i];
     var name = nativeInfo[0];
     if (name in knownProblems || name in currentlyUncallable)

data/vendor/v8/test/mjsunit/generated-transition-stub.js

@@ -0,0 +1,218 @@
+// Copyright 2013 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.
+
+// Flags: --allow-natives-syntax --compiled_transitions
+
+try {} catch (e) {}
+
+var iteration_count = 1;
+
+function transition1(a, i, v) {
+  a[i] = v;
+}
+
+//
+// Test PACKED SMI -> PACKED DOUBLE
+//
+
+var a1 = [0, 1, 2, 3, 4];
+transition1(a1, 0, 2.5);
+var a2 = [0, 1, 2, 3, 4];
+transition1(a2, 0, 2.5);
+assertFalse(%HasFastHoleyElements(a2));
+%OptimizeFunctionOnNextCall(transition1);
+
+var a3 = [0, 1, 2, 3, 4];
+assertTrue(%HasFastSmiElements(a3));
+transition1(a3, 0, 2.5);
+assertFalse(%HasFastHoleyElements(a3));
+assertEquals(4, a3[4]);
+assertEquals(2.5, a3[0]);
+
+// Test handling of hole.
+var a4 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+a4.length = 7;
+assertTrue(%HasFastSmiElements(a4));
+transition1(a4, 0, 2.5);
+assertFalse(%HasFastHoleyElements(a4));
+assertEquals(2.5, a4[0]);
+assertEquals(undefined, a4[8]);
+
+// Large array should deopt to runtimea
+for (j = 0; j < iteration_count; ++j) {
+  a5 = new Array();
+  for (i = 0; i < 0x40000; ++i) {
+    a5[i] = 0;
+  }
+  assertTrue(%HasFastSmiElements(a5));
+  transition1(a5, 0, 2.5);
+  assertEquals(2.5, a5[0]);
+}
+
+//
+// Test HOLEY SMI -> HOLEY DOUBLE
+//
+
+function transition2(a, i, v) {
+  a[i] = v;
+}
+
+var b1 = [0, 1, 2, , 4];
+transition2(b1, 0, 2.5);
+var b2 = [0, 1, 2, , 4];
+transition2(b2, 0, 2.5);
+assertTrue(%HasFastHoleyElements(b2));
+%OptimizeFunctionOnNextCall(transition2);
+
+var b3 = [0, 1, 2, , 4];
+assertTrue(%HasFastSmiElements(b3));
+assertTrue(%HasFastHoleyElements(b3));
+transition2(b3, 0, 2.5);
+assertTrue(%HasFastHoleyElements(b3));
+assertEquals(4, b3[4]);
+assertEquals(2.5, b3[0]);
+
+// Large array should deopt to runtime
+for (j = 0; j < iteration_count; ++j) {
+  b4 = [0, ,0];
+  for (i = 3; i < 0x40000; ++i) {
+    b4[i] = 0;
+  }
+  assertTrue(%HasFastSmiElements(b4));
+  transition2(b4, 0, 2.5);
+  assertEquals(2.5, b4[0]);
+}
+
+//
+// Test PACKED DOUBLE -> PACKED OBJECT
+//
+
+function transition3(a, i, v) {
+  a[i] = v;
+}
+
+var c1 = [0, 1, 2, 3.5, 4];
+transition3(c1, 0, new Object());
+var c2 = [0, 1, 2, 3.5, 4];
+transition3(c2, 0, new Object());
+assertTrue(%HasFastObjectElements(c2));
+assertTrue(!%HasFastHoleyElements(c2));
+%OptimizeFunctionOnNextCall(transition3);
+
+var c3 = [0, 1, 2, 3.5, 4];
+assertTrue(%HasFastDoubleElements(c3));
+assertTrue(!%HasFastHoleyElements(c3));
+transition3(c3, 0, new Array());
+assertTrue(!%HasFastHoleyElements(c3));
+assertTrue(%HasFastObjectElements(c3));
+assertEquals(4, c3[4]);
+assertEquals(0, c3[0].length);
+
+// Large array under the deopt threshold should be able to trigger GC without
+// causing crashes.
+for (j = 0; j < iteration_count; ++j) {
+  c4 = [0, 2.5, 0];
+  for (i = 3; i < 0xa000; ++i) {
+    c4[i] = 0;
+  }
+  assertTrue(%HasFastDoubleElements(c4));
+  assertTrue(!%HasFastHoleyElements(c4));
+  transition3(c4, 0, new Array(5));
+  assertTrue(!%HasFastHoleyElements(c4));
+  assertTrue(%HasFastObjectElements(c4));
+  assertEquals(5, c4[0].length);
+}
+
+// Large array should deopt to runtime
+for (j = 0; j < iteration_count; ++j) {
+  c5 = [0, 2.5, 0];
+  for (i = 3; i < 0x40000; ++i) {
+    c5[i] = 0;
+  }
+  assertTrue(%HasFastDoubleElements(c5));
+  assertTrue(!%HasFastHoleyElements(c5));
+  transition3(c5, 0, new Array(5));
+  assertTrue(!%HasFastHoleyElements(c5));
+  assertTrue(%HasFastObjectElements(c5));
+  assertEquals(5, c5[0].length);
+}
+
+//
+// Test HOLEY DOUBLE -> HOLEY OBJECT
+//
+
+function transition4(a, i, v) {
+    a[i] = v;
+}
+
+var d1 = [0, 1, , 3.5, 4];
+transition4(d1, 0, new Object());
+var d2 = [0, 1, , 3.5, 4];
+transition4(d2, 0, new Object());
+assertTrue(%HasFastObjectElements(d2));
+assertTrue(%HasFastHoleyElements(d2));
+%OptimizeFunctionOnNextCall(transition4);
+
+var d3 = [0, 1, , 3.5, 4];
+assertTrue(%HasFastDoubleElements(d3));
+assertTrue(%HasFastHoleyElements(d3));
+transition4(d3, 0, new Array());
+assertTrue(%HasFastHoleyElements(d3));
+assertTrue(%HasFastObjectElements(d3));
+assertEquals(4, d3[4]);
+assertEquals(0, d3[0].length);
+
+// Large array under the deopt threshold should be able to trigger GC without
+// causing crashes.
+for (j = 0; j < iteration_count; ++j) {
+  d4 = [, 2.5, ,];
+  for (i = 3; i < 0xa000; ++i) {
+    d4[i] = 0;
+  }
+  assertTrue(%HasFastDoubleElements(d4));
+  assertTrue(%HasFastHoleyElements(d4));
+  transition4(d4, 0, new Array(5));
+  assertTrue(%HasFastHoleyElements(d4));
+  assertTrue(%HasFastObjectElements(d4));
+  assertEquals(5, d4[0].length);
+  assertEquals(undefined, d4[2]);
+}
+
+// Large array should deopt to runtime
+for (j = 0; j < iteration_count; ++j) {
+  d5 = [, 2.5, ,];
+  for (i = 3; i < 0x40000; ++i) {
+    d5[i] = 0;
+  }
+  assertTrue(%HasFastDoubleElements(d5));
+  assertTrue(%HasFastHoleyElements(d5));
+  transition4(d5, 0, new Array(5));
+  assertTrue(%HasFastHoleyElements(d5));
+  assertTrue(%HasFastObjectElements(d5));
+  assertEquals(5, d5[0].length);
+  assertEquals(undefined, d5[2]);
+}

data/vendor/v8/test/mjsunit/greedy.js

@@ -25,7 +25,7 @@
 // (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: --gc-greedy
+// Flags: --gc-greedy --noverify-heap
 
 function IterativeFib(n) {
   var f0 = 0, f1 = 1;

data/vendor/v8/test/mjsunit/harmony/block-conflicts.js

@@ -35,7 +35,8 @@
 function CheckException(e) {
   var string = e.toString();
   assertTrue(string.indexOf("has already been declared") >= 0 ||
-             string.indexOf("redeclaration") >= 0);  return 'Conflict';
+             string.indexOf("redeclaration") >= 0);
+  return 'Conflict';
 }
 
 

data/vendor/v8/test/mjsunit/harmony/block-let-crankshaft.js

@@ -25,7 +25,7 @@
 // (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: --harmony-scoping --allow-natives-syntax
+// Flags: --harmony-scoping --allow-natives-syntax --noparallel-recompilation
 
 // TODO(ES6): properly activate extended mode
 "use strict";

data/vendor/v8/test/mjsunit/harmony/collections.js

@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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:
@@ -65,9 +65,11 @@ TestInvalidCalls(new WeakMap);
 // Test expected behavior for Sets
 function TestSet(set, key) {
   assertFalse(set.has(key));
-  set.add(key);
+  assertSame(undefined, set.add(key));
   assertTrue(set.has(key));
-  set.delete(key);
+  assertTrue(set.delete(key));
+  assertFalse(set.has(key));
+  assertFalse(set.delete(key));
   assertFalse(set.has(key));
 }
 function TestSetBehavior(set) {
@@ -87,7 +89,7 @@ TestSetBehavior(new Set);
 
 // Test expected mapping behavior for Maps and WeakMaps
 function TestMapping(map, key, value) {
-  map.set(key, value);
+  assertSame(undefined, map.set(key, value));
   assertSame(value, map.get(key));
 }
 function TestMapBehavior1(m) {
@@ -117,12 +119,12 @@ TestMapBehavior2(new Map);
 // Test expected querying behavior of Maps and WeakMaps
 function TestQuery(m) {
   var key = new Object;
-  TestMapping(m, key, 'to-be-present');
-  assertTrue(m.has(key));
-  assertFalse(m.has(new Object));
-  TestMapping(m, key, undefined);
-  assertFalse(m.has(key));
-  assertFalse(m.has(new Object));
+  var values = [ 'x', 0, +Infinity, -Infinity, true, false, null, undefined ];
+  for (var i = 0; i < values.length; i++) {
+    TestMapping(m, key, values[i]);
+    assertTrue(m.has(key));
+    assertFalse(m.has(new Object));
+  }
 }
 TestQuery(new Map);
 TestQuery(new WeakMap);
@@ -311,4 +313,60 @@ TestBogusReceivers(bogusReceiversTestSet);
 // Stress Test
 // There is a proposed stress-test available at the es-discuss mailing list
 // which cannot be reasonably automated.  Check it out by hand if you like:
-// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html
+// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html
+
+
+// Set and Map size getters
+var setSizeDescriptor = Object.getOwnPropertyDescriptor(Set.prototype, 'size');
+assertEquals(undefined, setSizeDescriptor.value);
+assertEquals(undefined, setSizeDescriptor.set);
+assertTrue(setSizeDescriptor.get instanceof Function);
+assertEquals(undefined, setSizeDescriptor.get.prototype);
+assertFalse(setSizeDescriptor.enumerable);
+assertTrue(setSizeDescriptor.configurable);
+
+var s = new Set();
+assertFalse(s.hasOwnProperty('size'));
+for (var i = 0; i < 10; i++) {
+  assertEquals(i, s.size);
+  s.add(i);
+}
+for (var i = 9; i >= 0; i--) {
+  s.delete(i);
+  assertEquals(i, s.size);
+}
+
+
+var mapSizeDescriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+assertEquals(undefined, mapSizeDescriptor.value);
+assertEquals(undefined, mapSizeDescriptor.set);
+assertTrue(mapSizeDescriptor.get instanceof Function);
+assertEquals(undefined, mapSizeDescriptor.get.prototype);
+assertFalse(mapSizeDescriptor.enumerable);
+assertTrue(mapSizeDescriptor.configurable);
+
+var m = new Map();
+assertFalse(m.hasOwnProperty('size'));
+for (var i = 0; i < 10; i++) {
+  assertEquals(i, m.size);
+  m.set(i, i);
+}
+for (var i = 9; i >= 0; i--) {
+  m.delete(i);
+  assertEquals(i, m.size);
+}
+
+// Test clear
+var a = new Set();
+s.add(42);
+assertTrue(s.has(42));
+s.clear();
+assertFalse(s.has(42));
+assertEquals(0, s.size);
+
+var m = new Map();
+m.set(42, true);
+assertTrue(m.has(42));
+m.clear();
+assertFalse(m.has(42));
+assertEquals(0, m.size);

data/vendor/v8/test/mjsunit/harmony/debug-blockscopes.js

@@ -376,7 +376,7 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x:'y'}, 0, exec_state);
   // The function scope contains a temporary iteration variable.
-  CheckScopeContent({x:'y'}, 1, exec_state);
+  CheckScopeContent({'.for.x':'y'}, 1, exec_state);
 };
 for_loop_1();
 EndTest();
@@ -401,7 +401,7 @@ listener_delegate = function(exec_state) {
   CheckScopeContent({x:3}, 0, exec_state);
   CheckScopeContent({x:'y'}, 1, exec_state);
   // The function scope contains a temporary iteration variable.
-  CheckScopeContent({x:'y'}, 2, exec_state);
+  CheckScopeContent({'.for.x':'y'}, 2, exec_state);
 };
 for_loop_2();
 EndTest();

data/vendor/v8/test/mjsunit/harmony/module-linking.js

@@ -27,10 +27,188 @@
 
 // Flags: --harmony-modules --harmony-scoping
 
-// Test basic module linking.
+// Test basic module linking and initialization.
 
 "use strict";
 
+module R {
+  // At this point, only functions and modules are initialized.
+  assertEquals(undefined, v)
+  assertEquals(undefined, vv)
+  assertEquals(undefined, R.v)
+  assertEquals(undefined, M.v)
+  assertEquals(undefined, MM.v)
+  assertEquals(undefined, F.v)
+  assertEquals(undefined, G.v)
+  assertThrows(function() { l }, ReferenceError)
+  assertThrows(function() { ll }, ReferenceError)
+  assertThrows(function() { R.l }, ReferenceError)
+  assertThrows(function() { M.l }, ReferenceError)
+  assertThrows(function() { MM.l }, ReferenceError)
+  assertThrows(function() { F.l }, ReferenceError)
+  assertThrows(function() { G.l }, ReferenceError)
+  assertThrows(function() { c }, ReferenceError)
+  assertThrows(function() { cc }, ReferenceError)
+  assertThrows(function() { R.c }, ReferenceError)
+  assertThrows(function() { M.c }, ReferenceError)
+  assertThrows(function() { MM.c }, ReferenceError)
+  assertThrows(function() { F.c }, ReferenceError)
+  assertThrows(function() { G.c }, ReferenceError)
+  assertEquals(4, f())
+  assertEquals(24, ff())
+  assertEquals(4, R.f())
+  assertEquals(14, M.f())
+  assertEquals(34, MM.f())
+  assertEquals(44, F.f())
+  assertEquals(14, G.f())
+
+  // All properties should already exist on the instance objects, though.
+  assertTrue("v" in R)
+  assertTrue("v" in RR)
+  assertTrue("v" in M)
+  assertTrue("v" in MM)
+  assertTrue("v" in F)
+  assertTrue("v" in G)
+  assertTrue("l" in R)
+  assertTrue("l" in RR)
+  assertTrue("l" in M)
+  assertTrue("l" in MM)
+  assertTrue("l" in F)
+  assertTrue("l" in G)
+  assertTrue("c" in R)
+  assertTrue("c" in RR)
+  assertTrue("c" in M)
+  assertTrue("c" in MM)
+  assertTrue("c" in F)
+  assertTrue("c" in G)
+  assertTrue("f" in R)
+  assertTrue("f" in RR)
+  assertTrue("f" in M)
+  assertTrue("f" in MM)
+  assertTrue("f" in F)
+  assertTrue("f" in G)
+  assertTrue("M" in R)
+  assertTrue("M" in RR)
+  assertTrue("RR" in R)
+  assertTrue("RR" in RR)
+
+  // And aliases should be identical.
+  assertSame(R, RR)
+  assertSame(R, R.RR)
+  assertSame(M, R.M)
+  assertSame(M, G)
+
+  // We can only assign to var.
+  assertEquals(-1, v = -1)
+  assertEquals(-2, R.v = -2)
+  assertEquals(-2, v)
+  assertEquals(-2, R.v)
+
+  assertThrows(function() { l = -1 }, ReferenceError)
+  assertThrows(function() { R.l = -2 }, ReferenceError)
+  assertThrows(function() { l }, ReferenceError)
+  assertThrows(function() { R.l }, ReferenceError)
+
+  assertThrows(function() { eval("c = -1") }, SyntaxError)
+  assertThrows(function() { R.c = -2 }, TypeError)
+
+  // Initialize first bunch of variables.
+  export var v = 1
+  export let l = 2
+  export const c = 3
+  export function f() { return 4 }
+
+  assertEquals(1, v)
+  assertEquals(1, R.v)
+  assertEquals(2, l)
+  assertEquals(2, R.l)
+  assertEquals(3, c)
+  assertEquals(3, R.c)
+
+  assertEquals(-3, v = -3)
+  assertEquals(-4, R.v = -4)
+  assertEquals(-3, l = -3)
+  assertEquals(-4, R.l = -4)
+  assertThrows(function() { eval("c = -3") }, SyntaxError)
+  assertThrows(function() { R.c = -4 }, TypeError)
+
+  assertEquals(-4, v)
+  assertEquals(-4, R.v)
+  assertEquals(-4, l)
+  assertEquals(-4, R.l)
+  assertEquals(3, c)
+  assertEquals(3, R.c)
+
+  // Initialize nested module.
+  export module M {
+    export var v = 11
+    export let l = 12
+    export const c = 13
+    export function f() { return 14 }
+  }
+
+  assertEquals(11, M.v)
+  assertEquals(11, G.v)
+  assertEquals(12, M.l)
+  assertEquals(12, G.l)
+  assertEquals(13, M.c)
+  assertEquals(13, G.c)
+
+  // Initialize non-exported variables.
+  var vv = 21
+  let ll = 22
+  const cc = 23
+  function ff() { return 24 }
+
+  assertEquals(21, vv)
+  assertEquals(22, ll)
+  assertEquals(23, cc)
+
+  // Initialize non-exported module.
+  module MM {
+    export var v = 31
+    export let l = 32
+    export const c = 33
+    export function f() { return 34 }
+  }
+
+  assertEquals(31, MM.v)
+  assertEquals(32, MM.l)
+  assertEquals(33, MM.c)
+
+  // Recursive self reference.
+  export module RR = R
+}
+
+// Initialize sibling module that was forward-used.
+module F {
+  assertEquals(undefined, v)
+  assertEquals(undefined, F.v)
+  assertThrows(function() { l }, ReferenceError)
+  assertThrows(function() { F.l }, ReferenceError)
+  assertThrows(function() { c }, ReferenceError)
+  assertThrows(function() { F.c }, ReferenceError)
+
+  export var v = 41
+  export let l = 42
+  export const c = 43
+  export function f() { return 44 }
+
+  assertEquals(41, v)
+  assertEquals(41, F.v)
+  assertEquals(42, l)
+  assertEquals(42, F.l)
+  assertEquals(43, c)
+  assertEquals(43, F.c)
+}
+
+// Define recursive module alias.
+module G = R.M
+
+
+
+// Second test with side effects and more module nesting.
+
 let log = "";
 
 export let x = (log += "1");
@@ -117,5 +295,4 @@ assertSame(M2, M1.A2);
 assertSame(M1, M1.A2.A1);
 assertSame(M2, M2.A1.A2);
 
-// TODO(rossberg): inner declarations are not executed yet.
-// assertEquals("1234567890", log);
+assertEquals("1234567890", log);