Update the mozilla tests to new version (as of 2010-06-29).

mozilla-tests/js1_8_1/trace/trace-test.js

-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
  * License.
  *
  * The Original Code is JavaScript Engine testing utilities.
  *
  * The Initial Developer of the Original Code is
  * Mozilla Foundation.
  * Portions created by the Initial Developer are Copyright (C) 2008
  * the Initial Developer. All Rights Reserved.
  *
  * Contributor(s): Mike Shaver
  *                 Brendan Eich
  *                 Andreas Gal
  *                 David Anderson
+ *                 Boris Zbarsky
+ *                 Brian Crowder
+ *                 Blake Kaplan
+ *                 Robert Sayre
+ *                 Vladimir Vukicevic
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either the GNU General Public License Version 2 or later (the "GPL"), or
  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 var gTestfile = 'trace-test.js';
 //-----------------------------------------------------------------------------
 var BUGNUMBER = 'none';
 var summary = 'trace-capability mini-testsuite';
 
 printBugNumber(BUGNUMBER);
 printStatus (summary);
- 
+
+jit(true);
+
+/**
+ * A number of the tests in this file depend on the setting of
+ * HOTLOOP.  Define some constants up front, so they're easy to grep
+ * for.
+ */
+// The HOTLOOP constant we depend on; only readable from our stats
+// object in debug builds.
+const haveTracemonkey = !!(this.tracemonkey)
+  const HOTLOOP = haveTracemonkey ? tracemonkey.HOTLOOP : 2;
+// The loop count at which we trace
+const RECORDLOOP = HOTLOOP;
+// The loop count at which we run the trace
+const RUNLOOP = HOTLOOP + 1;
+
+var gDoMandelbrotTest = true;
+if ("gSkipSlowTests" in this && gSkipSlowTests) {
+    print("** Skipping slow tests");
+    gDoMandelbrotTest = false;
+}
+
+if (!('gSrcdir' in this))
+    gSrcdir = '.';
+
+if (!('gReportSummary' in this))
+    gReportSummary = true;
+
 var testName = null;
 if ("arguments" in this && arguments.length > 0)
   testName = arguments[0];
 var fails = [], passes=[];
 
+function jitstatHandler(f)
+{
+  if (!haveTracemonkey) 
+    return;
+
+  // XXXbz this is a nasty hack, but I can't figure out a way to
+  // just use jitstats.tbl here
+  f("recorderStarted");
+  f("recorderAborted");
+  f("traceCompleted");
+  f("sideExitIntoInterpreter");
+  f("timeoutIntoInterpreter");
+  f("typeMapMismatchAtEntry");
+  f("returnToDifferentLoopHeader");
+  f("traceTriggered");
+  f("globalShapeMismatchAtEntry");
+  f("treesTrashed");
+  f("slotPromoted");
+  f("unstableLoopVariable");
+  f("breakLoopExits");
+  f("returnLoopExits");
+  f("mergedLoopExits");
+  f("noCompatInnerTrees");
+}
+
+var jitProps = {};
+jitstatHandler(function(prop) {
+                 jitProps[prop] = true;
+               });
+var hadJITstats = false;
+for (var p in jitProps)
+  hadJITstats = true;
+
 function test(f)
 {
-  if (!testName || testName == f.name)
-    check(f.name, f(), f.expected);
-}
-
-function check(desc, actual, expected)
-{
-  if (expected == actual) {
-    reportCompare(expected + '', actual + '', desc);
-    passes.push(desc);
-    return print(desc, ": passed");
-  }
+  // Clear out any accumulated confounding state in the oracle / JIT cache.
+  gc();
+
+  if (!testName || testName == f.name) {
+    var expectedJITstats = f.jitstats;
+    if (hadJITstats && expectedJITstats)
+    {
+      var expectedProps = {};
+      jitstatHandler(function(prop) {
+                       if (prop in expectedJITstats)
+                         expectedProps[prop] = true;
+                     });
+      for (var p in expectedJITstats)
+      {
+        if (!(p in expectedProps))
+          throw "Bad property in " + f.name + ".jitstats: " + p;
+      }
+    }
+
+    // Collect our jit stats
+    var localJITstats = {};
+    jitstatHandler(function(prop) {
+                     localJITstats[prop] = tracemonkey[prop];
+                   });
+    check(f.name, f(), f.expected, localJITstats, expectedJITstats);
+  }
+}
+
+function map_test(t, cases)
+{
+  for (var i = 0; i < cases.length; i++) {
+    function c() { return t(cases[i].input); }
+    c.expected = cases[i].expected;
+    c.name = t.name + "(" + uneval(cases[i].input) + ")";
+    test(c);
+  }
+}
+
+// Use this function to compare expected and actual test results.
+// Types must match.
+// For numbers, treat NaN as matching NaN, distinguish 0 and -0, and
+// tolerate a certain degree of error for other values.
+//
+// These are the same criteria used by the tests in js/tests, except that
+// we distinguish 0 and -0.
+function close_enough(expected, actual)
+{
+  if (typeof expected != typeof actual)
+    return false;
+  if (typeof expected != 'number')
+    return actual == expected;
+
+  // Distinguish NaN from other values.  Using x != x comparisons here
+  // works even if tests redefine isNaN.
+  if (actual != actual)
+    return expected != expected
+      if (expected != expected)
+        return false;
+
+  // Tolerate a certain degree of error.
+  if (actual != expected)
+    return Math.abs(actual - expected) <= 1E-10;
+
+  // Distinguish 0 and -0.
+  if (actual == 0)
+    return (1 / actual > 0) == (1 / expected > 0);
+
+  return true;
+}
+
+function check(desc, actual, expected, oldJITstats, expectedJITstats)
+{
+  var pass = false;
+  if (close_enough(expected, actual)) {
+    pass = true;
+    jitstatHandler(function(prop) {
+        if (expectedJITstats && prop in expectedJITstats &&
+            expectedJITstats[prop] !=
+            tracemonkey[prop] - oldJITstats[prop]) {
+          pass = false;
+        }
+      });
+    if (pass) {
+      reportCompare(expected, actual, desc);
+      passes.push(desc);
+      return print("TEST-PASS | trace-test.js |", desc);
+    }
+  }
+
+  if (expected instanceof RegExp) {
+    pass = reportMatch(expected, actual + '', desc);
+    if (pass) {
+      jitstatHandler(function(prop) {
+          if (expectedJITstats && prop in expectedJITstats &&
+              expectedJITstats[prop] !=
+              tracemonkey[prop] - oldJITstats[prop]) {
+            pass = false;
+          }
+        });
+    }
+    if (pass) {
+      passes.push(desc);
+      return print(desc, ": passed");
+    }
+  }
+
   reportCompare(expected, actual, desc);
+
   fails.push(desc);
-  print(desc, ": FAILED: expected", typeof(expected), "(", expected, ") != actual",
-        typeof(actual), "(", actual, ")");
+  var expectedStats = "";
+  if (expectedJITstats) {
+    jitstatHandler(function(prop) {
+        if (prop in expectedJITstats) {
+          if (expectedStats)
+            expectedStats += " ";
+          expectedStats +=
+            prop + ": " + expectedJITstats[prop];
+        }
+      });
+  }
+  var actualStats = "";
+  if (expectedJITstats) {
+    jitstatHandler(function(prop) {
+        if (prop in expectedJITstats) {
+          if (actualStats)
+            actualStats += " ";
+          actualStats += prop + ": " + (tracemonkey[prop]-oldJITstats[prop]);
+        }
+      });
+  }
+  print("TEST-UNEXPECTED-FAIL | trace-test.js |", desc, ": expected", typeof(expected),
+        "(", uneval(expected), ")",
+        (expectedStats ? " [" + expectedStats + "] " : ""),
+        "!= actual",
+        typeof(actual), "(", uneval(actual), ")",
+        (actualStats ? " [" + actualStats + "] " : ""));
 }
 
 function ifInsideLoop()
 {
   var cond = true, intCond = 5, count = 0;
   for (var i = 0; i < 100; i++) {
     if (cond)
       count++;
     if (intCond)
       count++;
@@ skipping 18 matching lines @@
 if (!testName || testName == "bitwiseGlobal") {
   bitwiseAndValue = Math.pow(2,32);
   for (var i = 0; i < 60000; i++)
     bitwiseAndValue = bitwiseAndValue & i;
   check("bitwiseGlobal", bitwiseAndValue, 0);
 }
 
 
 function equalInt()
 {
-  var i1 = 55;
-  var hits = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+  var i1 = 55, one = 1, zero = 0, undef;
+  var o1 = { }, o2 = { };
+  var s = "5";
+  var hits = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
   for (var i = 0; i < 5000; i++) {
     if (i1 == 55) hits[0]++;
     if (i1 != 56) hits[1]++;
     if (i1 < 56)  hits[2]++;
     if (i1 > 50)  hits[3]++;
     if (i1 <= 60) hits[4]++;
     if (i1 >= 30) hits[5]++;
     if (i1 == 7)  hits[6]++;
     if (i1 != 55) hits[7]++;
     if (i1 < 30)  hits[8]++;
     if (i1 > 90)  hits[9]++;
     if (i1 <= 40) hits[10]++;
     if (i1 >= 70) hits[11]++;
+    if (o1 == o2) hits[12]++;
+    if (o2 != null) hits[13]++;
+    if (s < 10) hits[14]++;
+    if (true < zero) hits[15]++;
+    if (undef > one) hits[16]++;
+    if (undef < zero) hits[17]++;
   }
   return hits.toString();
 }
-equalInt.expected = "5000,5000,5000,5000,5000,5000,0,0,0,0,0,0,0,0,0,0,0,0,0";
+equalInt.expected = "5000,5000,5000,5000,5000,5000,0,0,0,0,0,0,0,5000,5000,0,0,0";
 test(equalInt);
 
 var a;
 function setelem()
 {
   a = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
   a = a.concat(a, a, a);
   var l = a.length;
   for (var i = 0; i < l; i++) {
     a[i] = i;
@@ skipping 54 matching lines @@
 arith.expected = 9800;
 test(arith);
 
 function lsh_inner(n)
 {
   var r;
   for (var i = 0; i < 35; i++)
     r = 0x1 << n;
   return r;
 }
-function lsh()
-{
-  return [lsh_inner(15),lsh_inner(55),lsh_inner(1),lsh_inner(0)];
-}
-lsh.expected = "32768,8388608,2,1";
-test(lsh);
+
+map_test (lsh_inner,
+          [{input: 15, expected: 32768},
+           {input: 55, expected: 8388608},
+           {input: 1,  expected: 2},
+           {input: 0,  expected: 1}]);
 
 function rsh_inner(n)
 {
   var r;
   for (var i = 0; i < 35; i++)
     r = 0x11010101 >> n;
   return r;
 }
-function rsh()
-{
-  return [rsh_inner(8),rsh_inner(5),rsh_inner(35),rsh_inner(-1)];
-}
-rsh.expected = "1114369,8914952,35659808,0";
-test(rsh);
+map_test (rsh_inner,
+          [{input: 8,  expected: 1114369},
+           {input: 5,  expected: 8914952},
+           {input: 35, expected: 35659808},
+           {input: -1, expected: 0}]);
 
 function ursh_inner(n)
 {
   var r;
   for (var i = 0; i < 35; i++)
     r = -55 >>> n;
   return r;
 }
-function ursh() {
-  return [ursh_inner(8),ursh_inner(33),ursh_inner(0),ursh_inner(1)];
-}
-ursh.expected = "16777215,2147483620,4294967241,2147483620";
-test(ursh);
+map_test (ursh_inner,
+          [{input: 8,  expected: 16777215},
+           {input: 33, expected: 2147483620},
+           {input: 0,  expected: 4294967241},
+           {input: 1,  expected: 2147483620}]);
 
 function doMath_inner(cos)
 {
-    var s = 0;
-    var sin = Math.sin;
-    for (var i = 0; i < 200; i++)
-        s = -Math.pow(sin(i) + cos(i * 0.75), 4);
-    return s;
+  var s = 0;
+  var sin = Math.sin;
+  for (var i = 0; i < 200; i++)
+    s = -Math.pow(sin(i) + cos(i * 0.75), 4);
+  return s;
 }
 function doMath() {
   return doMath_inner(Math.cos);
 }
 doMath.expected = -0.5405549555611059;
 test(doMath);
 
 function fannkuch() {
-   var count = Array(8);
-   var r = 8;
-   var done = 0;
-   while (done < 40) {
-      // write-out the first 30 permutations
-      done += r;
-      while (r != 1) { count[r - 1] = r; r--; }
-      while (true) {
-         count[r] = count[r] - 1;
-         if (count[r] > 0) break;
-         r++;
-      }
-   }
-   return done;
+  var count = Array(8);
+  var r = 8;
+  var done = 0;
+  while (done < 40) {
+    // write-out the first 30 permutations
+    done += r;
+    while (r != 1) { count[r - 1] = r; r--; }
+    while (true) {
+      count[r] = count[r] - 1;
+      if (count[r] > 0) break;
+      r++;
+    }
+  }
+  return done;
 }
 fannkuch.expected = 41;
 test(fannkuch);
 
 function xprop()
 {
   a = 0;
   for (var i = 0; i < 20; i++)
     a += 7;
   return a;
@@ skipping 39 matching lines @@
   return 1;
 }
 function glob_f2() {
   return glob_f1();
 }
 function call()
 {
   var q1 = 0, q2 = 0, q3 = 0, q4 = 0, q5 = 0;
   var o = {};
   function f1() {
-      return 1;
+    return 1;
   }
   function f2(f) {
-      return f();
+    return f();
   }
   o.f = f1;
   for (var i = 0; i < 100; ++i) {
-      q1 += f1();
-      q2 += f2(f1);
-      q3 += glob_f1();
-      q4 += o.f();
-      q5 += glob_f2();
+    q1 += f1();
+    q2 += f2(f1);
+    q3 += glob_f1();
+    q4 += o.f();
+    q5 += glob_f2();
   }
-  var ret = [q1, q2, q3, q4, q5];
+  var ret = String([q1, q2, q3, q4, q5]);
   return ret;
 }
 call.expected =  "100,100,100,100,100";
 test(call);
 
 function setprop()
 {
   var obj = { a:-1 };
   var obj2 = { b:-1, a:-1 };
   for (var i = 0; i < 20; i++) {
     obj2.b = obj.a = i;
   }
   return [obj.a, obj2.a, obj2.b].toString();
 }
 setprop.expected =  "19,-1,19";
 test(setprop);
 
 function testif() {
         var q = 0;
         for (var i = 0; i < 100; i++) {
                 if ((i & 1) == 0)
                         q++;
                 else
                         q--;
         }
-    return q;
+  return q;
 }
-testif.expected = "0";
+testif.expected = 0;
 test(testif);
 
+var globalinc = 0;
 function testincops(n) {
   var i = 0, o = {p:0}, a = [0];
   n = 100;
 
   for (i = 0; i < n; i++);
   while (i-- > 0);
   for (i = 0; i < n; ++i);
   while (--i >= 0);
 
-  for (o.p = 0; o.p < n; o.p++);
-  while (o.p-- > 0);
-  for (o.p = 0; o.p < n; ++o.p);
-  while (--o.p >= 0);
+  for (o.p = 0; o.p < n; o.p++) globalinc++;
+  while (o.p-- > 0) --globalinc;
+  for (o.p = 0; o.p < n; ++o.p) ++globalinc;
+  while (--o.p >= 0) globalinc--;
 
   ++i; // set to 0
   for (a[i] = 0; a[i] < n; a[i]++);
   while (a[i]-- > 0);
   for (a[i] = 0; a[i] < n; ++a[i]);
   while (--a[i] >= 0);
 
-  return [++o.p, ++a[i]].toString();
+  return [++o.p, ++a[i], globalinc].toString();
 }
-testincops.expected = "0,0";
+testincops.expected = "0,0,0";
 test(testincops);
 
 function trees() {
   var i = 0, o = [0,0,0];
   for (i = 0; i < 100; ++i) {
     if ((i & 1) == 0) o[0]++;
     else if ((i & 2) == 0) o[1]++;
     else o[2]++;
   }
-  return o;
+  return String(o);
 }
 trees.expected = "50,25,25";
 test(trees);
 
 function unboxint() {
-    var q = 0;
-    var o = [4];
-    for (var i = 0; i < 100; ++i)
-        q = o[0] << 1;
-    return q;
+  var q = 0;
+  var o = [4];
+  for (var i = 0; i < 100; ++i)
+    q = o[0] << 1;
+  return q;
 }
-unboxint.expected = "8";
+unboxint.expected = 8;
 test(unboxint);
 
 function strings()
 {
   var a = [], b = -1;
   var s = "abcdefghij", s2 = "a";
   var f = "f";
   var c = 0, d = 0, e = 0, g = 0;
   for (var i = 0; i < 10; i++) {
-    a[i] = (s.substring(i, i+1) + s[i] + String.fromCharCode(s2.charCodeAt(0) + i)).concat(i);
+    a[i] = (s.substring(i, i+1) + s[i] + String.fromCharCode(s2.charCodeAt(0) + i)).concat(i) + i;
     if (s[i] == f)
       c++;
     if (s[i] != 'b')
       d++;
     if ("B" > s2)
       g++; // f already used
     if (s2 < "b")
       e++;
     b = s.length;
   }
   return a.toString() + b + c + d + e + g;
 }
-strings.expected = "aaa0,bbb1,ccc2,ddd3,eee4,fff5,ggg6,hhh7,iii8,jjj91019100";
+strings.expected = "aaa00,bbb11,ccc22,ddd33,eee44,fff55,ggg66,hhh77,iii88,jjj991019100";
 test(strings);
 
+function dependentStrings()
+{
+  var a = [];
+  var t = "abcdefghijklmnopqrst";
+  for (var i = 0; i < 10; i++) {
+    var s = t.substring(2*i, 2*i + 2);
+    a[i] = s + s.length;
+  }
+  return a.join("");
+}
+dependentStrings.expected = "ab2cd2ef2gh2ij2kl2mn2op2qr2st2";
+test(dependentStrings);
+
 function stringConvert()
 {
   var a = [];
   var s1 = "F", s2 = "1.3", s3 = "5";
   for (var i = 0; i < 10; i++) {
     a[0] = 1 >> s1;
     a[1] = 10 - s2;
     a[2] = 15 * s3;
     a[3] = s3 | 32;
-    // a[4] = s2 + 60;
+    a[4] = s2 + 60;
     // a[5] = 9 + s3;
     // a[6] = -s3;
     a[7] = s3 & "7";
     // a[8] = ~s3;
   }
   return a.toString();
 }
-stringConvert.expected = "1,8.7,75,37,,,,5";
+stringConvert.expected = "1,8.7,75,37,1.360,,,5";
 test(stringConvert);
 
 function orTestHelper(a, b, n)
 {
   var k = 0;
   for (var i = 0; i < n; i++) {
     if (a || b)
       k += i;
   }
   return k;
 }
 
+var orNaNTest1, orNaNTest2;
+
+orNaNTest1 = new Function("return orTestHelper(NaN, NaN, 10);");
+orNaNTest1.name = 'orNaNTest1';
+orNaNTest1.expected = 0;
+orNaNTest2 = new Function("return orTestHelper(NaN, 1, 10);");
+orNaNTest2.name = 'orNaNTest2';
+orNaNTest2.expected = 45;
+test(orNaNTest1);
+test(orNaNTest2);
+
 function andTestHelper(a, b, n)
 {
   var k = 0;
   for (var i = 0; i < n; i++) {
     if (a && b)
       k += i;
   }
   return k;
 }
 
 if (!testName || testName == "truthies") {
   (function () {
-     var opsies   = ["||", "&&"];
-     var falsies  = [null, undefined, false, NaN, 0, ""];
-     var truthies = [{}, true, 1, 42, 1/0, -1/0, "blah"];
-     var boolies  = [falsies, truthies];
+    var opsies   = ["||", "&&"];
+    var falsies  = [null, undefined, false, NaN, 0, ""];
+    var truthies = [{}, true, 1, 42, 1/0, -1/0, "blah"];
+    var boolies  = [falsies, truthies];
 
-     // The for each here should abort tracing, so that this test framework
-     // relies only on the interpreter while the orTestHelper and andTestHelper
-     //  functions get trace-JITed.
-     for each (var op in opsies) {
-       for (var i in boolies) {
-         for (var j in boolies[i]) {
-           var x = uneval(boolies[i][j]);
-           for (var k in boolies) {
-             for (var l in boolies[k]) {
-               var y = uneval(boolies[k][l]);
-               var prefix = (op == "||") ? "or" : "and";
-               var f = new Function("return " + prefix + "TestHelper(" + x + "," + y + ",10)");
-               f.name = prefix + "Test(" + x + "," + y + ")";
-               f.expected = eval(x + op + y) ? 45 : 0;
-               test(f);
-             }
-           }
-         }
-       }
-     }
-   })();
+    // The for each here should abort tracing, so that this test framework
+    // relies only on the interpreter while the orTestHelper and andTestHelper
+    //  functions get trace-JITed.
+    for each (var op in opsies) {
+        for (var i in boolies) {
+          for (var j in boolies[i]) {
+            var x = uneval(boolies[i][j]);
+            for (var k in boolies) {
+              for (var l in boolies[k]) {
+                var y = uneval(boolies[k][l]);
+                var prefix = (op == "||") ? "or" : "and";
+                var f = new Function("return " + prefix + "TestHelper(" + x + "," + y + ",10)");
+                f.name = prefix + "Test(" + x + "," + y + ")";
+                f.expected = eval(x + op + y) ? 45 : 0;
+                test(f);
+              }
+            }
+          }
+        }
+      }
+  })();
 }
 
 function nonEmptyStack1Helper(o, farble) {
-    var a = [];
-    var j = 0;
-    for (var i in o)
-        a[j++] = i;
-    return a.join("");
+  var a = [];
+  var j = 0;
+  for (var i in o)
+    a[j++] = i;
+  return a.join("");
 }
 
 function nonEmptyStack1() {
-    return nonEmptyStack1Helper({a:1,b:2,c:3,d:4,e:5,f:6,g:7,h:8}, "hi");
+  return nonEmptyStack1Helper({a:1,b:2,c:3,d:4,e:5,f:6,g:7,h:8}, "hi");
 }
 
 nonEmptyStack1.expected = "abcdefgh";
 test(nonEmptyStack1);
 
 function nonEmptyStack2()
 {
   var a = 0;
   for (var c in {a:1, b:2, c:3}) {
     for (var i = 0; i < 10; i++)
@@ skipping 30 matching lines @@
 function newTest()
 {
   var a = [];
   for (var i = 0; i < 10; i++)
     a[i] = new MyConstructor(i);
   return a.join("");
 }
 newTest.expected = "0123456789";
 test(newTest);
 
-function shapelessArgCalleeLoop(f, a)
-{
-  for (var i = 0; i < 10; i++)
-    f(i, a);
-}
-
-function shapelessVarCalleeLoop(f, a)
-{
-  var g = f;
-  for (var i = 0; i < 10; i++)
-    g(i, a);
-}
-
-function shapelessLetCalleeLoop(f, a)
+// The following functions use a delay line of length 2 to change the value
+// of the callee without exiting the traced loop. This is obviously tuned to
+// match the current HOTLOOP setting of 2.
+function shapelessArgCalleeLoop(f, g, h, a)
 {
   for (var i = 0; i < 10; i++) {
-    let g = f;
-    g(i, a);
+    f(i, a);
+    f = g;
+    g = h;
   }
 }
 
-function shapelessUnknownCalleeLoop(f, g, a)
+function shapelessVarCalleeLoop(f0, g, h, a)
+{
+  var f = f0;
+  for (var i = 0; i < 10; i++) {
+    f(i, a);
+    f = g;
+    g = h;
+  }
+}
+
+function shapelessLetCalleeLoop(f0, g, h, a)
 {
   for (var i = 0; i < 10; i++) {
-    (f || g)(i, a);
-    f = null;
+    let f = f0;
+    f(i, a);
+    f = g;
+    g = h;
+  }
+}
+
+function shapelessUnknownCalleeLoop(n, f, g, h, a)
+{
+  for (var i = 0; i < 10; i++) {
+    (n || f)(i, a);
+    f = g;
+    g = h;
   }
 }
 
 function shapelessCalleeTest()
 {
   var a = [];
-  shapelessArgCalleeLoop(function (i, a) a[i] = i, a);
-  shapelessVarCalleeLoop(function (i, a) a[10 + i] = i, a);
-  shapelessLetCalleeLoop(function (i, a) a[20 + i] = i, a);
-  shapelessUnknownCalleeLoop(null, function (i, a) a[30 + i] = i, a);
+
+  var helper = function (i, a) a[i] = i;
+  shapelessArgCalleeLoop(helper, helper, function (i, a) a[i] = -i, a);
+
+  helper = function (i, a) a[10 + i] = i;
+  shapelessVarCalleeLoop(helper, helper, function (i, a) a[10 + i] = -i, a);
+
+  helper = function (i, a) a[20 + i] = i;
+  shapelessLetCalleeLoop(helper, helper, function (i, a) a[20 + i] = -i, a);
+
+  helper = function (i, a) a[30 + i] = i;
+  shapelessUnknownCalleeLoop(null, helper, helper, function (i, a) a[30 + i] = -i, a);
+
   try {
-    shapelessUnknownCalleeLoop(null, {hack: 42}, a);
+    helper = {hack: 42};
+    shapelessUnknownCalleeLoop(null, helper, helper, helper, a);
   } catch (e) {
-    if (e + "" != "TypeError: g is not a function")
+    if (e + "" != "TypeError: f is not a function")
       print("shapelessUnknownCalleeLoop: unexpected exception " + e);
   }
   return a.join("");
 }
-shapelessCalleeTest.expected = "0123456789012345678901234567890123456789";
+shapelessCalleeTest.expected = "01-2-3-4-5-6-7-8-901-2-3-4-5-6-7-8-9012345678901-2-3-4-5-6-7-8-9";
 test(shapelessCalleeTest);
 
 function typeofTest()
 {
   var values = ["hi", "hi", "hi", null, 5, 5.1, true, undefined, /foo/, typeofTest, [], {}], types = [];
   for (var i = 0; i < values.length; i++)
     types[i] = typeof values[i];
   return types.toString();
 }
 typeofTest.expected = "string,string,string,object,number,number,boolean,undefined,object,function,object,object";
 test(typeofTest);
 
+function joinTest()
+{
+  var s = "";
+  var a = [];
+  for (var i = 0; i < 8; i++)
+    a[i] = [String.fromCharCode(97 + i)];
+  for (i = 0; i < 8; i++) {
+    for (var j = 0; j < 8; j++)
+      a[i][1 + j] = j;
+  }
+  for (i = 0; i < 8; i++)
+    s += a[i].join(",");
+  return s;
+}
+joinTest.expected = "a,0,1,2,3,4,5,6,7b,0,1,2,3,4,5,6,7c,0,1,2,3,4,5,6,7d,0,1,2,3,4,5,6,7e,0,1,2,3,4,5,6,7f,0,1,2,3,4,5,6,7g,0,1,2,3,4,5,6,7h,0,1,2,3,4,5,6,7";
+test(joinTest);
+
+function arity1(x)
+{
+  return (x == undefined) ? 1 : 0;
+}
+function missingArgTest() {
+  var q;
+  for (var i = 0; i < 10; i++) {
+    q = arity1();
+  }
+  return q;
+}
+missingArgTest.expected = 1;
+test(missingArgTest);
+
+JSON = function () {
+  return {
+  stringify: function stringify(value, whitelist) {
+      switch (typeof(value)) {
+      case "object":
+      return value.constructor.name;
+      }
+    }
+  };
+}();
+
+function missingArgTest2() {
+  var testPairs = [
+    ["{}", {}],
+    ["[]", []],
+    ['{"foo":"bar"}', {"foo":"bar"}],
+    ]
+
+    var a = [];
+  for (var i=0; i < testPairs.length; i++) {
+    var s = JSON.stringify(testPairs[i][1])
+      a[i] = s;
+  }
+  return a.join(",");
+}
+missingArgTest2.expected = /(Object,Array,Object|{},\[\],{"foo":"bar"})/;
+test(missingArgTest2);
+
+function deepForInLoop() {
+  // NB: the number of props set in C is arefully tuned to match HOTLOOP = 2.
+  function C(){this.p = 1, this.q = 2}
+  C.prototype = {p:1, q:2, r:3, s:4, t:5};
+  var o = new C;
+  var j = 0;
+  var a = [];
+  for (var i in o)
+    a[j++] = i;
+  return a.join("");
+}
+deepForInLoop.expected = "pqrst";
+test(deepForInLoop);
+
+function nestedExit(x) {
+  var q = 0;
+  for (var i = 0; i < 10; ++i)
+  {
+    if (x)
+            ++q;
+  }
+}
+function nestedExitLoop() {
+  for (var j = 0; j < 10; ++j)
+    nestedExit(j < 7);
+  return "ok";
+}
+nestedExitLoop.expected = "ok";
+test(nestedExitLoop);
+
+function bitsinbyte(b) {
+  var m = 1, c = 0;
+  while(m<0x100) {
+    if(b & m) c++;
+    m <<= 1;
+  }
+  return 1;
+}
+function TimeFunc(func) {
+  var x,y;
+  for(var y=0; y<256; y++) func(y);
+}
+function nestedExit2() {
+  TimeFunc(bitsinbyte);
+  return "ok";
+}
+nestedExit2.expected = "ok";
+test(nestedExit2);
+
+function parsingNumbers() {
+  var s1 = "123";
+  var s1z = "123zzz";
+  var s2 = "123.456";
+  var s2z = "123.456zzz";
+
+  var e1 = 123;
+  var e2 = 123.456;
+
+  var r1, r1z, r2, r2z;
+
+  for (var i = 0; i < 10; i++) {
+    r1 = parseInt(s1);
+    r1z = parseInt(s1z);
+    r2 = parseFloat(s2);
+    r2z = parseFloat(s2z);
+  }
+
+  if (r1 == e1 && r1z == e1 && r2 == e2 && r2z == e2)
+    return "ok";
+  return "fail";
+}
+parsingNumbers.expected = "ok";
+test(parsingNumbers);
+
+function matchInLoop() {
+  var k = "hi";
+  for (var i = 0; i < 10; i++) {
+    var result = k.match(/hi/) != null;
+  }
+  return result;
+}
+matchInLoop.expected = true;
+test(matchInLoop);
+
+function testMatchAsCondition() {
+    var a = ['0', '0', '0', '0'];
+    var r = /0/;
+    "x".q;
+    for (var z = 0; z < 4; z++)
+        a[z].match(r) ? 1 : 2;
+}
+test(testMatchAsCondition);
+
+function deep1(x) {
+  if (x > 90)
+    return 1;
+  return 2;
+}
+function deep2() {
+  for (var i = 0; i < 100; ++i)
+    deep1(i);
+  return "ok";
+}
+deep2.expected = "ok";
+test(deep2);
+
+function heavyFn1(i) { 
+    if (i == 3) {
+        var x = 3;
+        return [0, i].map(function (i) i + x);
+    }
+    return [];
+}
+function testHeavy() {
+    for (var i = 0; i <= 3; i++)
+        heavyFn1(i);
+}
+test(testHeavy);
+
+function heavyFn2(i) {
+    if (i < 1000)
+        return heavyFn1(i);
+    return function () i;
+}
+function testHeavy2() {
+    for (var i = 0; i <= 3; i++)
+        heavyFn2(i);
+}
+test(testHeavy2);
+
+var merge_type_maps_x = 0, merge_type_maps_y = 0;
+function merge_type_maps() {
+  for (merge_type_maps_x = 0; merge_type_maps_x < 50; ++merge_type_maps_x)
+    if ((merge_type_maps_x & 1) == 1)
+            ++merge_type_maps_y;
+  return [merge_type_maps_x,merge_type_maps_y].join(",");
+}
+merge_type_maps.expected = "50,25";
+test(merge_type_maps)
+
+function inner_double_outer_int() {
+  function f(i) {
+    for (var m = 0; m < 20; ++m)
+            for (var n = 0; n < 100; n += i)
+        ;
+    return n;
+  }
+  return f(.5);
+}
+inner_double_outer_int.expected = 100;
+test(inner_double_outer_int);
+
+function newArrayTest()
+{
+  var a = [];
+  for (var i = 0; i < 10; i++)
+    a[i] = new Array();
+  return a.map(function(x) x.length).toString();
+}
+newArrayTest.expected="0,0,0,0,0,0,0,0,0,0";
+test(newArrayTest);
+
+function stringSplitTest()
+{
+  var s = "a,b"
+    var a = null;
+  for (var i = 0; i < 10; ++i)
+    a = s.split(",");
+  return a.join();
+}
+stringSplitTest.expected="a,b";
+test(stringSplitTest);
+
+function stringSplitIntoArrayTest()
+{
+  var s = "a,b"
+    var a = [];
+  for (var i = 0; i < 10; ++i)
+    a[i] = s.split(",");
+  return a.join();
+}
+stringSplitIntoArrayTest.expected="a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b";
+test(stringSplitIntoArrayTest);
+
+function forVarInWith() {
+  function foo() ({notk:42});
+  function bar() ({p:1, q:2, r:3, s:4, t:5});
+  var o = foo();
+  var a = [];
+  with (o) {
+    for (var k in bar())
+      a[a.length] = k;
+  }
+  return a.join("");
+}
+forVarInWith.expected = "pqrst";
+test(forVarInWith);
+
+function inObjectTest() {
+  var o = {p: 1, q: 2, r: 3, s: 4, t: 5};
+  var r = 0;
+  for (var i in o) {
+    if (!(i in o))
+      break;
+    if ((i + i) in o)
+      break;
+    ++r;
+  }
+  return r;
+}
+inObjectTest.expected = 5;
+test(inObjectTest);
+
+function inArrayTest() {
+  var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+  for (var i = 0; i < a.length; i++) {
+    if (!(i in a))
+      break;
+  }
+  return i;
+}
+inArrayTest.expected = 10;
+test(inArrayTest);
+
+function innerLoopIntOuterDouble() {
+  var n = 10000, i=0, j=0, count=0, limit=0;
+  for (i = 1; i <= n; ++i) {
+    limit = i * 1;
+    for (j = 0; j < limit; ++j) {
+            ++count;
+    }
+  }
+  return "" + count;
+}
+innerLoopIntOuterDouble.expected="50005000";
+test(innerLoopIntOuterDouble);
+
+function outerline(){
+  var i=0;
+  var j=0;
+
+  for (i = 3; i<= 100000; i+=2)
+  {
+    for (j = 3; j < 1000; j+=2)
+    {
+            if ((i & 1) == 1)
+        break;
+    }
+  }
+  return "ok";
+}
+outerline.expected="ok";
+test(outerline);
+
+function addAccumulations(f) {
+  var a = f();
+  var b = f();
+  return a() + b();
+}
+
+function loopingAccumulator() {
+  var x = 0;
+  return function () {
+    for (var i = 0; i < 10; ++i) {
+      ++x;
+    }
+    return x;
+  }
+}
+
+function testLoopingAccumulator() {
+        var x = addAccumulations(loopingAccumulator);
+        return x;
+}
+testLoopingAccumulator.expected = 20;
+test(testLoopingAccumulator);
+
+function testBranchingLoop() {
+  var x = 0;
+  for (var i=0; i < 100; ++i) {
+    if (i == 51) {
+      x += 10;
+    }
+    x++;
+  }
+  return x;
+}
+testBranchingLoop.expected = 110;
+test(testBranchingLoop);
+
+function testBranchingUnstableLoop() {
+  var x = 0;
+  for (var i=0; i < 100; ++i) {
+    if (i == 51) {
+      x += 10.1;
+    }
+    x++;
+  }
+  return x;
+}
+testBranchingUnstableLoop.expected = 110.1;
+test(testBranchingUnstableLoop);
+
+function testBranchingUnstableLoopCounter() {
+  var x = 0;
+  for (var i=0; i < 100; ++i) {
+    if (i == 51) {
+      i += 1.1;
+    }
+    x++;
+  }
+  return x;
+}
+testBranchingUnstableLoopCounter.expected = 99;
+test(testBranchingUnstableLoopCounter);
+
+
+function testBranchingUnstableObject() {
+  var x = {s: "a"};
+  var t = "";
+  for (var i=0; i < 100; ++i) {
+    if (i == 51)
+    {
+      x.s = 5;
+    }
+    t += x.s;
+  }
+  return t.length;
+}
+testBranchingUnstableObject.expected = 100;
+test(testBranchingUnstableObject);
+
+function testArrayDensityChange() {
+  var x = [];
+  var count = 0;
+  for (var i=0; i < 100; ++i) {
+    x[i] = "asdf";
+  }
+  for (var i=0; i < x.length; ++i) {
+    if (i == 51)
+    {
+      x[199] = "asdf";
+    }
+    if (x[i])
+      count += x[i].length;
+  }
+  return count;
+}
+testArrayDensityChange.expected = 404;
+test(testArrayDensityChange);
+
+function testDoubleToStr() {
+  var x = 0.0;
+  var y = 5.5;
+  for (var i = 0; i < 200; i++) {
+    x += parseFloat(y.toString());
+  }
+  return x;
+}
+testDoubleToStr.expected = 5.5*200;
+test(testDoubleToStr);
+
+function testNumberToString() {
+  var x = new Number(0);
+  for (var i = 0; i < 4; i++)
+    x.toString();
+}
+test(testNumberToString);
+
+function testDecayingInnerLoop() {
+  var i, j, k = 10;
+  for (i = 0; i < 5000; ++i) {
+    for (j = 0; j < k; ++j);
+    --k;
+  }
+  return i;
+}
+testDecayingInnerLoop.expected = 5000;
+test(testDecayingInnerLoop);
+
+function testContinue() {
+  var i;
+  var total = 0;
+  for (i = 0; i < 20; ++i) {
+    if (i == 11)
+            continue;
+    total++;
+  }
+  return total;
+}
+testContinue.expected = 19;
+test(testContinue);
+
+function testContinueWithLabel() {
+  var i = 0;
+  var j = 20;
+checkiandj :
+  while (i<10) {
+    i+=1;
+        checkj :
+    while (j>10) {
+            j-=1;
+            if ((j%2)==0)
+        continue checkj;
+    }
+  }
+  return i + j;
+}
+testContinueWithLabel.expected = 20;
+test(testContinueWithLabel);
+
+function testDivision() {
+  var a = 32768;
+  var b;
+  while (b !== 1) {
+    b = a / 2;
+    a = b;
+  }
+  return a;
+}
+testDivision.expected = 1;
+test(testDivision);
+
+function testDivisionFloat() {
+  var a = 32768.0;
+  var b;
+  while (b !== 1) {
+    b = a / 2.0;
+    a = b;
+  }
+  return a === 1.0;
+}
+testDivisionFloat.expected = true;
+test(testDivisionFloat);
+
+function testToUpperToLower() {
+  var s = "Hello", s1, s2;
+  for (i = 0; i < 100; ++i) {
+    s1 = s.toLowerCase();
+    s2 = s.toUpperCase();
+  }
+  return s1 + s2;
+}
+testToUpperToLower.expected = "helloHELLO";
+test(testToUpperToLower);
+
+function testReplace2() {
+  var s = "H e l l o", s1;
+  for (i = 0; i < 100; ++i)
+    s1 = s.replace(" ", "");
+  return s1;
+}
+testReplace2.expected = "He l l o";
+test(testReplace2);
+
+function testBitwise() {
+  var x = 10000;
+  var y = 123456;
+  var z = 987234;
+  for (var i = 0; i < 50; i++) {
+    x = x ^ y;
+    y = y | z;
+    z = ~x;
+  }
+  return x + y + z;
+}
+testBitwise.expected = -1298;
+test(testBitwise);
+
+function testSwitch() {
+  var x = 0;
+  var ret = 0;
+  for (var i = 0; i < 100; ++i) {
+    switch (x) {
+    case 0:
+      ret += 1;
+      break;
+    case 1:
+      ret += 2;
+      break;
+    case 2:
+      ret += 3;
+      break;
+    case 3:
+      ret += 4;
+      break;
+    default:
+      x = 0;
+    }
+    x++;
+  }
+  return ret;
+}
+testSwitch.expected = 226;
+test(testSwitch);
+
+function testSwitchString() {
+  var x = "asdf";
+  var ret = 0;
+  for (var i = 0; i < 100; ++i) {
+    switch (x) {
+    case "asdf":
+      x = "asd";
+      ret += 1;
+      break;
+    case "asd":
+      x = "as";
+      ret += 2;
+      break;
+    case "as":
+      x = "a";
+      ret += 3;
+      break;
+    case "a":
+      x = "foo";
+      ret += 4;
+      break;
+    default:
+      x = "asdf";
+    }
+  }
+  return ret;
+}
+testSwitchString.expected = 200;
+test(testSwitchString);
+
+function testNegZero1Helper(z) {
+  for (let j = 0; j < 5; ++j) { z = -z; }
+  return Math.atan2(0, -0) == Math.atan2(0, z);
+}
+
+var testNegZero1 = function() { return testNegZero1Helper(0); }
+  testNegZero1.expected = true;
+testNegZero1.name = 'testNegZero1';
+testNegZero1Helper(1);
+test(testNegZero1);
+
+// No test case, just make sure this doesn't assert.
+function testNegZero2() {
+  var z = 0;
+  for (let j = 0; j < 5; ++j) { ({p: (-z)}); }
+}
+testNegZero2();
+
+function testConstSwitch() {
+  var x;
+  for (var j=0;j<5;++j) { switch(1.1) { case NaN: case 2: } x = 2; }
+  return x;
+}
+testConstSwitch.expected = 2;
+test(testConstSwitch);
+
+function testConstSwitch2() {
+  var x;
+  for (var j = 0; j < 4; ++j) { switch(0/0) { } }
+  return "ok";
+}
+testConstSwitch2.expected = "ok";
+test(testConstSwitch2);
+
+function testConstIf() {
+  var x;
+  for (var j=0;j<5;++j) { if (1.1 || 5) { } x = 2;}
+  return x;
+}
+testConstIf.expected = 2;
+test(testConstIf);
+
+function testTypeofHole() {
+  var a = new Array(6);
+  a[5] = 3;
+  for (var i = 0; i < 6; ++i)
+    a[i] = typeof a[i];
+  return a.join(",");
+}
+testTypeofHole.expected = "undefined,undefined,undefined,undefined,undefined,number"
+  test(testTypeofHole);
+
+function testNativeLog() {
+  var a = new Array(5);
+  for (var i = 0; i < 5; i++) {
+    a[i] = Math.log(Math.pow(Math.E, 10));
+  }
+  return a.join(",");
+}
+testNativeLog.expected = "10,10,10,10,10";
+test(testNativeLog);
+
+function test_JSOP_ARGSUB() {
+  function f0() { return arguments[0]; }
+  function f1() { return arguments[1]; }
+  function f2() { return arguments[2]; }
+  function f3() { return arguments[3]; }
+  function f4() { return arguments[4]; }
+  function f5() { return arguments[5]; }
+  function f6() { return arguments[6]; }
+  function f7() { return arguments[7]; }
+  function f8() { return arguments[8]; }
+  function f9() { return arguments[9]; }
+  var a = [];
+  for (var i = 0; i < 10; i++) {
+    a[0] = f0('a');
+    a[1] = f1('a','b');
+    a[2] = f2('a','b','c');
+    a[3] = f3('a','b','c','d');
+    a[4] = f4('a','b','c','d','e');
+    a[5] = f5('a','b','c','d','e','f');
+    a[6] = f6('a','b','c','d','e','f','g');
+    a[7] = f7('a','b','c','d','e','f','g','h');
+    a[8] = f8('a','b','c','d','e','f','g','h','i');
+    a[9] = f9('a','b','c','d','e','f','g','h','i','j');
+  }
+  return a.join("");
+}
+test_JSOP_ARGSUB.expected = "abcdefghij";
+test(test_JSOP_ARGSUB);
+
+function test_JSOP_ARGCNT() {
+  function f0() { return arguments.length; }
+  function f1() { return arguments.length; }
+  function f2() { return arguments.length; }
+  function f3() { return arguments.length; }
+  function f4() { return arguments.length; }
+  function f5() { return arguments.length; }
+  function f6() { return arguments.length; }
+  function f7() { return arguments.length; }
+  function f8() { return arguments.length; }
+  function f9() { return arguments.length; }
+  var a = [];
+  for (var i = 0; i < 10; i++) {
+    a[0] = f0('a');
+    a[1] = f1('a','b');
+    a[2] = f2('a','b','c');
+    a[3] = f3('a','b','c','d');
+    a[4] = f4('a','b','c','d','e');
+    a[5] = f5('a','b','c','d','e','f');
+    a[6] = f6('a','b','c','d','e','f','g');
+    a[7] = f7('a','b','c','d','e','f','g','h');
+    a[8] = f8('a','b','c','d','e','f','g','h','i');
+    a[9] = f9('a','b','c','d','e','f','g','h','i','j');
+  }
+  return a.join(",");
+}
+test_JSOP_ARGCNT.expected = "1,2,3,4,5,6,7,8,9,10";
+test(test_JSOP_ARGCNT);
+
+function testNativeMax() {
+  var out = [], k;
+  for (var i = 0; i < 5; ++i) {
+    k = Math.max(k, i);
+  }
+  out.push(k);
+
+  k = 0;
+  for (var i = 0; i < 5; ++i) {
+    k = Math.max(k, i);
+  }
+  out.push(k);
+
+  for (var i = 0; i < 5; ++i) {
+    k = Math.max(0, -0);
+  }
+  out.push((1 / k) < 0);
+  return out.join(",");
+}
+testNativeMax.expected = "NaN,4,false";
+test(testNativeMax);
+
+function testFloatArrayIndex() {
+  var a = [];
+  for (var i = 0; i < 10; ++i) {
+    a[3] = 5;
+    a[3.5] = 7;
+  }
+  return a[3] + "," + a[3.5];
+}
+testFloatArrayIndex.expected = "5,7";
+test(testFloatArrayIndex);
+
+function testStrict() {
+  var n = 10, a = [];
+  for (var i = 0; i < 10; ++i) {
+    a[0] = (n === 10);
+    a[1] = (n !== 10);
+    a[2] = (n === null);
+    a[3] = (n == null);
+  }
+  return a.join(",");
+}
+testStrict.expected = "true,false,false,false";
+test(testStrict);
+
+function testSetPropNeitherMissNorHit() {
+  for (var j = 0; j < 5; ++j) { if (({}).__proto__ = 1) { } }
+  return "ok";
+}
+testSetPropNeitherMissNorHit.expected = "ok";
+test(testSetPropNeitherMissNorHit);
+
+function testPrimitiveConstructorPrototype() {
+  var f = function(){};
+  f.prototype = false;
+  for (let j=0;j<5;++j) { new f; }
+  return "ok";
+}
+testPrimitiveConstructorPrototype.expected = "ok";
+test(testPrimitiveConstructorPrototype);
+
+function testSideExitInConstructor() {
+  var FCKConfig = {};
+  FCKConfig.CoreStyles =
+    {
+            'Bold': { },
+            'Italic': { },
+            'FontFace': { },
+            'Size' :
+            {
+      Overrides: [ ]
+            },
+
+            'Color' :
+            {
+      Element: '',
+      Styles: {  },
+      Overrides: [  ]
+            },
+            'BackColor': {
+      Element : '',
+      Styles : { 'background-color' : '' }
+            },
+
+    };
+  var FCKStyle = function(A) {
+    A.Element;
+  };
+
+  var pass = true;
+  for (var s in FCKConfig.CoreStyles) {
+    var x = new FCKStyle(FCKConfig.CoreStyles[s]);
+    if (!x)
+      pass = false;
+  }
+  return pass;
+}
+testSideExitInConstructor.expected = true;
+test(testSideExitInConstructor);
+
+function testNot() {
+  var a = new Object(), b = null, c = "foo", d = "", e = 5, f = 0, g = 5.5, h = -0, i = true, j = false, k = undefined;
+  var r;
+  for (var i = 0; i < 10; ++i)
+    r = [!a, !b, !c, !d, !e, !f, !g, !h, !i, !j, !k];
+  return r.join(",");
+}
+testNot.expected = "false,true,false,true,false,true,false,true,false,true,true";
+test(testNot);
+
+function doTestDifferingArgc(a, b)
+{
+  var k = 0;
+  for (var i = 0; i < 10; i++)
+  {
+    k += i;
+  }
+  return k;
+}
+function testDifferingArgc()
+{
+  var x = 0;
+  x += doTestDifferingArgc(1, 2);
+  x += doTestDifferingArgc(1);
+  x += doTestDifferingArgc(1, 2, 3);
+  return x;
+}
+testDifferingArgc.expected = 45*3;
+test(testDifferingArgc);
+
+function doTestMoreArgcThanNargs()
+{
+  var x = 0;
+  for (var i = 0; i < 10; i++)
+  {
+    x = x + arguments[3];
+  }
+  return x;
+}
+function testMoreArgcThanNargs()
+{
+  return doTestMoreArgcThanNargs(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+}
+testMoreArgcThanNargs.expected = 4*10;
+test(testMoreArgcThanNargs);
+
+// Test stack reconstruction after a nested exit
+function testNestedExitStackInner(j, counter) {
+  ++counter;
+  var b = 0;
+  for (var i = 1; i <= RUNLOOP; i++) {
+    ++b;
+    var a;
+    // Make sure that once everything has been traced we suddenly switch to
+    // a different control flow the first time we run the outermost tree,
+    // triggering a side exit.
+    if (j < RUNLOOP)
+      a = 1;
+    else
+      a = 0;
+    ++b;
+    b += a;
+  }
+  return counter + b;
+}
+function testNestedExitStackOuter() {
+  var counter = 0;
+  for (var j = 1; j <= RUNLOOP; ++j) {
+    for (var k = 1; k <= RUNLOOP; ++k) {
+      counter = testNestedExitStackInner(j, counter);
+    }
+  }
+  return counter;
+}
+testNestedExitStackOuter.expected = 81;
+test(testNestedExitStackOuter);
+
+function testHOTLOOPSize() {
+  return HOTLOOP > 1;
+}
+testHOTLOOPSize.expected = true;
+test(testHOTLOOPSize);
+
+function testMatchStringObject() {
+  var a = new String("foo");
+  var b;
+  for (i = 0; i < 300; i++)
+    b = a.match(/bar/);
+  return b;
+}
+testMatchStringObject.expected = null;
+test(testMatchStringObject);
+
+function innerSwitch(k)
+{
+  var m = 0;
+
+  switch (k)
+  {
+  case 0:
+    m = 1;
+    break;
+  }
+
+  return m;
+}
+function testInnerSwitchBreak()
+{
+  var r = new Array(5);
+  for (var i = 0; i < 5; i++)
+  {
+    r[i] = innerSwitch(0);
+  }
+
+  return r.join(",");
+}
+testInnerSwitchBreak.expected = "1,1,1,1,1";
+test(testInnerSwitchBreak);
+
+function testArrayNaNIndex()
+{
+  for (var j = 0; j < 4; ++j) { [this[NaN]]; }
+  for (var j = 0; j < 5; ++j) { if([1][-0]) { } }
+  return "ok";
+}
+testArrayNaNIndex.expected = "ok";
+test(testArrayNaNIndex);
+
+function innerTestInnerMissingArgs(a,b,c,d)
+{
+  if (a) {
+  } else {
+  }
+}
+function doTestInnerMissingArgs(k)
+{
+  for (i = 0; i < 10; i++) {
+    innerTestInnerMissingArgs(k);
+  }
+}
+function testInnerMissingArgs()
+{
+  doTestInnerMissingArgs(1);
+  doTestInnerMissingArgs(0);
+  return 1;
+}
+testInnerMissingArgs.expected = 1;  //Expected: that we don't crash.
+test(testInnerMissingArgs);
+
+function regexpLastIndex()
+{
+  var n = 0;
+  var re = /hi/g;
+  var ss = " hi hi hi hi hi hi hi hi hi hi";
+  for (var i = 0; i < 10; i++) {
+    // re.exec(ss);
+    n += (re.lastIndex > 0) ? 3 : 0;
+    re.lastIndex = 0;
+  }
+  return n;
+}
+regexpLastIndex.expected = 0; // 30;
+test(regexpLastIndex);
+
+function testHOTLOOPCorrectness() {
+  var b = 0;
+  for (var i = 0; i < HOTLOOP; ++i)
+    ++b;
+  return b;
+}
+testHOTLOOPCorrectness.expected = HOTLOOP;
+testHOTLOOPCorrectness.jitstats = {
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 0
+};
+// Change the global shape right before doing the test
+this.testHOTLOOPCorrectnessVar = 1;
+test(testHOTLOOPCorrectness);
+
+function testRUNLOOPCorrectness() {
+  var b = 0;
+  for (var i = 0; i < RUNLOOP; ++i) {
+    ++b;
+  }
+  return b;
+}
+testRUNLOOPCorrectness.expected = RUNLOOP;
+testRUNLOOPCorrectness.jitstats = {
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 1
+};
+// Change the global shape right before doing the test
+this.testRUNLOOPCorrectnessVar = 1;
+test(testRUNLOOPCorrectness);
+
+function testDateNow() {
+  // Accessing global.Date for the first time will change the global shape,
+  // so do it before the loop starts; otherwise we have to loop an extra time
+  // to pick things up.
+  var time = Date.now();
+  for (var j = 0; j < RUNLOOP; ++j)
+    time = Date.now();
+  return "ok";
+}
+testDateNow.expected = "ok";
+testDateNow.jitstats = {
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 1
+};
+test(testDateNow);
+
+function testINITELEM()
+{
+  var x;
+  for (var i = 0; i < 10; ++i)
+    x = { 0: 5, 1: 5 };
+  return x[0] + x[1];
+}
+testINITELEM.expected = 10;
+test(testINITELEM);
+
+function testUndefinedBooleanCmp()
+{
+  var t = true, f = false, x = [];
+  for (var i = 0; i < 10; ++i) {
+    x[0] = t == undefined;
+    x[1] = t != undefined;
+    x[2] = t === undefined;
+    x[3] = t !== undefined;
+    x[4] = t < undefined;
+    x[5] = t > undefined;
+    x[6] = t <= undefined;
+    x[7] = t >= undefined;
+    x[8] = f == undefined;
+    x[9] = f != undefined;
+    x[10] = f === undefined;
+    x[11] = f !== undefined;
+    x[12] = f < undefined;
+    x[13] = f > undefined;
+    x[14] = f <= undefined;
+    x[15] = f >= undefined;
+  }
+  return x.join(",");
+}
+testUndefinedBooleanCmp.expected = "false,true,false,true,false,false,false,false,false,true,false,true,false,false,false,false";
+test(testUndefinedBooleanCmp);
+
+function testConstantBooleanExpr()
+{
+  for (var j = 0; j < 3; ++j) { if(true <= true) { } }
+  return "ok";
+}
+testConstantBooleanExpr.expected = "ok";
+test(testConstantBooleanExpr);
+
+function testNegativeGETELEMIndex()
+{
+  for (let i=0;i<3;++i) /x/[-4];
+  return "ok";
+}
+testNegativeGETELEMIndex.expected = "ok";
+test(testNegativeGETELEMIndex);
+
+function doTestInvalidCharCodeAt(input)
+{
+  var q = "";
+  for (var i = 0; i < 10; i++)
+    q += input.charCodeAt(i);
+  return q;
+}
+function testInvalidCharCodeAt()
+{
+  return doTestInvalidCharCodeAt("");
+}
+testInvalidCharCodeAt.expected = "NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN";
+test(testInvalidCharCodeAt);
+
+function FPQuadCmp()
+{
+  for (let j = 0; j < 3; ++j) { true == 0; }
+  return "ok";
+}
+FPQuadCmp.expected = "ok";
+test(FPQuadCmp);
+
+function testDestructuring() {
+  var t = 0;
+  for (var i = 0; i < HOTLOOP + 1; ++i) {
+    var [r, g, b] = [1, 1, 1];
+    t += r + g + b;
+  }
+  return t
+    }
+testDestructuring.expected = (HOTLOOP + 1) * 3;
+test(testDestructuring);
+
+function loopWithUndefined1(t, val) {
+  var a = new Array(6);
+  for (var i = 0; i < 6; i++)
+    a[i] = (t > val);
+  return a;
+}
+loopWithUndefined1(5.0, 2);     //compile version with val=int
+
+function testLoopWithUndefined1() {
+  return loopWithUndefined1(5.0).join(",");  //val=undefined
+};
+testLoopWithUndefined1.expected = "false,false,false,false,false,false";
+test(testLoopWithUndefined1);
+
+function loopWithUndefined2(t, dostuff, val) {
+  var a = new Array(6);
+  for (var i = 0; i < 6; i++) {
+    if (dostuff) {
+      val = 1; 
+      a[i] = (t > val);
+    } else {
+      a[i] = (val == undefined);
+    }
+  }
+  return a;
+}
+function testLoopWithUndefined2() {
+  var a = loopWithUndefined2(5.0, true, 2);
+  var b = loopWithUndefined2(5.0, true);
+  var c = loopWithUndefined2(5.0, false, 8);
+  var d = loopWithUndefined2(5.0, false);
+  return [a[0], b[0], c[0], d[0]].join(",");
+}
+testLoopWithUndefined2.expected = "true,true,false,true";
+test(testLoopWithUndefined2);
+
+//test no multitrees assert
+function testBug462388() {
+  var c = 0, v; for each (let x in ["",v,v,v]) { for (c=0;c<4;++c) { } }
+  return true;
+}
+testBug462388.expected = true;
+test(testBug462388);
+
+//test no multitrees assert
+function testBug462407() {
+  for each (let i in [0, {}, 0, 1.5, {}, 0, 1.5, 0, 0]) { }
+  return true;
+}
+testBug462407.expected = true;
+test(testBug462407);
+
+//test no multitrees assert
+function testBug463490() {
+  function f(a, b, d) {
+    for (var i = 0; i < 10; i++) {
+      if (d)
+        b /= 2;
+    }
+    return a + b;
+  }
+  //integer stable loop
+  f(2, 2, false);
+  //double stable loop
+  f(3, 4.5, false);
+  //integer unstable branch
+  f(2, 2, true);
+  return true;
+};
+testBug463490.expected = true;
+test(testBug463490);
+
+// Test no assert (bug 464089)
+function shortRecursiveLoop(b, c) {
+  for (var i = 0; i < c; i++) {
+    if (b)
+      shortRecursiveLoop(c - 1);
+  }
+}
+function testClosingRecursion() {
+  shortRecursiveLoop(false, 1);
+  shortRecursiveLoop(true, 3);
+  return true;
+}
+testClosingRecursion.expected = true;
+test(testClosingRecursion);
+
+// Test no assert or crash from outer recorders (bug 465145)
+function testBug465145() {
+        this.__defineSetter__("x", function(){});
+        this.watch("x", function(){});
+        y = this;
+        for (var z = 0; z < 2; ++z) { x = y };
+        this.__defineSetter__("x", function(){});
+        for (var z = 0; z < 2; ++z) { x = y };
+}
+
+function testTrueShiftTrue() {
+  var a = new Array(5);
+  for (var i=0;i<5;++i) a[i] = "" + (true << true);
+  return a.join(",");
+}
+testTrueShiftTrue.expected = "2,2,2,2,2";
+test(testTrueShiftTrue);
+
+// Test no assert or crash
+function testBug465261() {
+  for (let z = 0; z < 2; ++z) { for each (let x in [0, true, (void 0), 0, (void
+                                                                           0)]) { if(x){} } };
+  return true;
+}
+testBug465261.expected = true;
+test(testBug465261);
+
+function testBug465272() {
+  var a = new Array(5);
+  for (j=0;j<5;++j) a[j] = "" + ((5) - 2);
+  return a.join(",");
+}
+testBug465272.expected = "3,3,3,3,3"
+  test(testBug465272);
+
+function testBug465483() {
+        var a = new Array(4);
+        var c = 0;
+        for each (i in [4, 'a', 'b', (void 0)]) a[c++] = '' + (i + i);
+        return a.join(',');
+}
+testBug465483.expected = '8,aa,bb,NaN';
+test(testBug465483);
+
+function testNullCallee() {
+  try {
+    function f() {
+      var x = new Array(5);
+      for (var i = 0; i < 5; i++)
+        x[i] = a[i].toString();
+      return x.join(',');
+    }
+    f([[1],[2],[3],[4],[5]]);
+    f([null, null, null, null, null]);
+  } catch (e) {
+    return true;
+  }
+  return false;
+}
+testNullCallee.expected = true;
+test(testNullCallee);
+
+//test no multitrees assert
+function testBug466128() {
+    for (let a = 0; a < 3; ++a) {
+      for each (let b in [1, 2, "three", 4, 5, 6, 7, 8]) {
+      }
+    }
+    return true;
+}
+testBug466128.expected = true;
+test(testBug466128);
+
+//test no assert
+function testBug465688() {
+    for each (let d in [-0x80000000, -0x80000000]) - -d;
+    return true;
+}
+testBug465688.expected = true;
+test(testBug465688);
+
+//test no assert
+function testBug466262() {
+    var e = 1;
+    for (var d = 0; d < 3; ++d) {
+      if (d == 2) {
+        e = "";
+      }
+    }
+    return true;
+}
+testBug466262.expected = true;
+test(testBug466262);
+
+function testNewDate()
+{
+  // Accessing global.Date for the first time will change the global shape,
+  // so do it before the loop starts; otherwise we have to loop an extra time
+  // to pick things up.
+  var start = new Date();
+  var time = new Date();
+  for (var j = 0; j < RUNLOOP; ++j)
+    time = new Date();
+  return time > 0 && time >= start;
+}
+testNewDate.expected = true;
+testNewDate.jitstats = {
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 1
+};
+test(testNewDate);
+
+function testArrayPushPop() {
+  var a = [], sum1 = 0, sum2 = 0;
+  for (var i = 0; i < 10; ++i)
+    sum1 += a.push(i);
+  for (var i = 0; i < 10; ++i)
+    sum2 += a.pop();
+  a.push(sum1);
+  a.push(sum2);
+  return a.join(",");
+}
+testArrayPushPop.expected = "55,45";
+test(testArrayPushPop);
+
+function testSlowArrayPop() {
+    var a = [];
+    for (var i = 0; i < RUNLOOP; i++)
+        a[i] = [0];
+    a[RUNLOOP-1].__defineGetter__("0", function () { return 'xyzzy'; });
+
+    var last;
+    for (var i = 0; i < RUNLOOP; i++)
+        last = a[i].pop();  // reenters interpreter in getter
+    return last;
+}
+testSlowArrayPop.expected = 'xyzzy';
+test(testSlowArrayPop);
+
+// Same thing but it needs to reconstruct multiple stack frames (so,
+// multiple functions called inside the loop)
+function testSlowArrayPopMultiFrame() {    
+    var a = [];
+    for (var i = 0; i < RUNLOOP; i++)
+        a[i] = [0];
+    a[RUNLOOP-1].__defineGetter__("0", function () { return 23; });
+
+    function child(a, i) {
+        return a[i].pop();  // reenters interpreter in getter
+    }
+    function parent(a, i) {
+        return child(a, i);
+    }
+    function gramps(a, i) { 
+        return parent(a, i);
+    }
+
+    var last;
+    for (var i = 0; i < RUNLOOP; i++)
+        last = gramps(a, i);
+    return last;
+}
+testSlowArrayPopMultiFrame.expected = 23;
+test(testSlowArrayPopMultiFrame);
+
+// Same thing but nested trees, each reconstructing one or more stack frames 
+// (so, several functions with loops, such that the loops end up being
+// nested though they are not lexically nested)
+
+function testSlowArrayPopNestedTrees() {    
+    var a = [];
+    for (var i = 0; i < RUNLOOP; i++)
+        a[i] = [0];
+    a[RUNLOOP-1].__defineGetter__("0", function () { return 3.14159 });
+
+    function child(a, i, j, k) {
+        var last = 2.71828;
+        for (var l = 0; l < RUNLOOP; l++)
+            if (i == RUNLOOP-1 && j == RUNLOOP-1 && k == RUNLOOP-1)
+                last = a[l].pop();  // reenters interpreter in getter
+        return last;
+    }
+    function parent(a, i, j) {
+        var last;
+        for (var k = 0; k < RUNLOOP; k++)
+            last = child(a, i, j, k);
+        return last;
+    }
+    function gramps(a, i) { 
+        var last;
+        for (var j = 0; j < RUNLOOP; j++)
+            last = parent(a, i, j);
+        return last;
+    }
+
+    var last;
+    for (var i = 0; i < RUNLOOP; i++)
+        last = gramps(a, i);
+    return last;
+}
+testSlowArrayPopNestedTrees.expected = 3.14159;
+test(testSlowArrayPopNestedTrees);
+
+function testResumeOp() {
+  var a = [1,"2",3,"4",5,"6",7,"8",9,"10",11,"12",13,"14",15,"16"];
+  var x = "";
+  while (a.length > 0)
+    x += a.pop();
+  return x;
+}
+testResumeOp.expected = "16151413121110987654321";
+test(testResumeOp);
+
+function testUndefinedCmp() {
+  var a = false;
+  for (var j = 0; j < 4; ++j) { if (undefined < false) { a = true; } }
+  return a;
+}
+testUndefinedCmp.expected = false;
+test(testUndefinedCmp);
+
+function reallyDeepNestedExit(schedule)
+{
+  var c = 0, j = 0;
+  for (var i = 0; i < 5; i++) {
+    for (j = 0; j < 4; j++) {
+      c += (schedule[i*4 + j] == 1) ? 1 : 2;
+    }
+  }
+  return c;
+}
+function testReallyDeepNestedExit()
+{
+  var c = 0;
+  var schedule1 = new Array(5*4);
+  var schedule2 = new Array(5*4);
+  for (var i = 0; i < 5*4; i++) {
+    schedule1[i] = 0;
+    schedule2[i] = 0;
+  }
+  /**
+   * First innermost compile: true branch runs through.
+   * Second '': false branch compiles new loop edge.
+   * First outer compile: expect true branch.
+   * Second '': hit false branch.
+   */
+  schedule1[0*4 + 3] = 1;
+  var schedules = [schedule1,
+                   schedule2,
+                   schedule1,
+                   schedule2,
+                   schedule2];
+
+  for (var i = 0; i < 5; i++) {
+    c += reallyDeepNestedExit(schedules[i]);
+  }
+  return c;
+}
+testReallyDeepNestedExit.expected = 198;
+test(testReallyDeepNestedExit);
+
+function testRegExpTest() {
+  var r = /abc/;
+  var flag = false;
+  for (var i = 0; i < 10; ++i)
+    flag = r.test("abc");
+  return flag;
+}
+testRegExpTest.expected = true;
+test(testRegExpTest);
+
+function testNumToString() {
+  var r = [];
+  var d = 123456789;
+  for (var i = 0; i < 10; ++i) {
+    r = [
+      d.toString(),
+      (-d).toString(),
+      d.toString(10),
+      (-d).toString(10),
+      d.toString(16),
+      (-d).toString(16),
+      d.toString(36),
+      (-d).toString(36)
+      ];
+  }
+  return r.join(",");
+}
+testNumToString.expected = "123456789,-123456789,123456789,-123456789,75bcd15,-75bcd15,21i3v9,-21i3v9";
+test(testNumToString);
+
+function testLongNumToString() {
+    var s;
+    for (var i = 0; i < 5; i++)
+        s = (0x08000000).toString(2);
+    return s;
+}
+testLongNumToString.expected = '1000000000000000000000000000';
+test(testLongNumToString);
+
+function testSubstring() {
+  for (var i = 0; i < 5; ++i) {
+    actual = "".substring(5);
+  }
+  return actual;
+}
+testSubstring.expected = "";
+test(testSubstring);
+
+function testForInLoopChangeIteratorType() {
+  for(y in [0,1,2]) y = NaN;
+  (function(){
+    [].__proto__.u = void 0;
+    for (let y in [5,6,7,8])
+      y = NaN;
+    delete [].__proto__.u;
+  })()
+    return "ok";
+}
+testForInLoopChangeIteratorType.expected = "ok";
+test(testForInLoopChangeIteratorType);
+
+function testGrowDenseArray() {
+  var a = new Array();
+  for (var i = 0; i < 10; ++i)
+    a[i] |= 5;
+  return a.join(",");
+}
+testGrowDenseArray.expected = "5,5,5,5,5,5,5,5,5,5";
+test(testGrowDenseArray);
+
+function testCallProtoMethod() {
+  function X() { this.x = 1; }
+  X.prototype.getName = function () { return "X"; }
+
+  function Y() { this.x = 2; }
+  Y.prototype.getName = function() "Y";
+
+  var a = [new X, new X, new X, new X, new Y];
+  var s = '';
+  for (var i = 0; i < a.length; i++)
+    s += a[i].getName();
+  return s;
+}
+testCallProtoMethod.expected = 'XXXXY';
+test(testCallProtoMethod);
+
+function testTypeUnstableForIn() {
+  var a = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
+  var x = 0;
+  for (var i in a) {
+    i = parseInt(i);
+    x++;
+  }
+  return x;
+}
+testTypeUnstableForIn.expected = 16;
+test(testTypeUnstableForIn);
+
+function testAddUndefined() {
+  for (var j = 0; j < 3; ++j)
+    (0 + void 0) && 0;
+}
+test(testAddUndefined);
+
+function testStringify() {
+  var t = true, f = false, u = undefined, n = 5, d = 5.5, s = "x";
+  var a = [];
+  for (var i = 0; i < 10; ++i) {
+    a[0] = "" + t;
+    a[1] = t + "";
+    a[2] = "" + f;
+    a[3] = f + "";
+    a[4] = "" + u;
+    a[5] = u + "";
+    a[6] = "" + n;
+    a[7] = n + "";
+    a[8] = "" + d;
+    a[9] = d + "";
+    a[10] = "" + s;
+    a[11] = s + "";
+  }
+  return a.join(",");
+}
+testStringify.expected = "true,true,false,false,undefined,undefined,5,5,5.5,5.5,x,x";
+test(testStringify);
+
+function testObjectToString() {
+  var o = {toString: function()"foo"};
+  var s = "";
+  for (var i = 0; i < 10; i++)
+    s += o;
+  return s;
+}
+testObjectToString.expected = "foofoofoofoofoofoofoofoofoofoo";
+test(testObjectToString);
+
+function testObjectToNumber() {
+  var o = {valueOf: function()-3};
+  var x = 0;
+  for (var i = 0; i < 10; i++)
+    x -= o;
+  return x;
+}
+testObjectToNumber.expected = 30;
+test(testObjectToNumber);
+
+function my_iterator_next() {
+  if (this.i == 10) {
+    this.i = 0;
+    throw this.StopIteration;
+  }
+  return this.i++;
+}
+function testCustomIterator() {
+  var o = {
+  __iterator__: function () {
+      return {
+      i: 0,
+      next: my_iterator_next,
+      StopIteration: StopIteration
+      };
+    }
+  };
+  var a=[];
+  for (var k = 0; k < 100; k += 10) {
+    for(var j in o) {
+      a[k + (j >> 0)] = j*k;
+    }
+  }
+  return a.join();
+}
+testCustomIterator.expected = "0,0,0,0,0,0,0,0,0,0,0,10,20,30,40,50,60,70,80,90,0,20,40,60,80,100,120,140,160,180,0,30,60,90,120,150,180,210,240,270,0,40,80,120,160,200,240,280,320,360,0,50,100,150,200,250,300,350,400,450,0,60,120,180,240,300,360,420,480,540,0,70,140,210,280,350,420,490,560,630,0,80,160,240,320,400,480,560,640,720,0,90,180,270,360,450,540,630,720,810";
+test(testCustomIterator);
+
+function bug464403() {
+  print(8);
+  var u = [print, print, function(){}]
+    for each (x in u) for (u.e in [1,1,1,1]);
+  return "ok";
+}
+bug464403.expected = "ok";
+test(bug464403);
+
+function testBoxDoubleWithDoubleSizedInt()
+{
+  var i = 0;
+  var a = new Array(3);
+
+  while (i < a.length)
+    a[i++] = 0x5a827999;
+  return a.join(",");
+}
+testBoxDoubleWithDoubleSizedInt.expected = "1518500249,1518500249,1518500249";
+test(testBoxDoubleWithDoubleSizedInt);
+
+function testObjectOrderedCmp()
+{
+  var a = new Array(5);
+  for(var i=0;i<5;++i) a[i] = ({} < {});
+  return a.join(",");
+}
+testObjectOrderedCmp.expected = "false,false,false,false,false";
+test(testObjectOrderedCmp);
+
+function testObjectOrderedCmp2()
+{
+  var a = new Array(5);
+  for(var i=0;i<5;++i) a[i] = ("" <= null);
+  return a.join(",");
+}
+testObjectOrderedCmp2.expected = "true,true,true,true,true";
+test(testObjectOrderedCmp2);
+
+function testLogicalNotNaN() {
+  var i = 0;
+  var a = new Array(5);
+  while (i < a.length)
+    a[i++] = !NaN;
+  return a.join();
+}
+testLogicalNotNaN.expected = "true,true,true,true,true";
+test(testLogicalNotNaN);
+
+function testStringToInt32() {
+  var s = "";
+  for (let j = 0; j < 5; ++j) s += ("1e+81" ^  3);
+  return s;
+}
+testStringToInt32.expected = "33333";
+test(testStringToInt32);
+
+function testIn() {
+  var array = [3];
+  var obj = { "-1": 5, "1.7": 3, "foo": 5, "1": 7 };
+  var a = [];
+  for (let j = 0; j < 5; ++j) {
+    a.push("0" in array);
+    a.push(-1 in obj);
+    a.push(1.7 in obj);
+    a.push("foo" in obj);
+    a.push(1 in obj);
+    a.push("1" in array);  
+    a.push(-2 in obj);
+    a.push(2.7 in obj);
+    a.push("bar" in obj);
+    a.push(2 in obj);    
+  }
+  return a.join(",");
+}
+testIn.expected = "true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false";
+test(testIn);
+
+function testBranchCse() {
+  empty = [];
+  out = [];
+  for (var j=0;j<10;++j) { empty[42]; out.push((1 * (1)) | ""); }
+  return out.join(",");
+}
+testBranchCse.expected = "1,1,1,1,1,1,1,1,1,1";
+test(testBranchCse);
+
+function testMulOverflow() {
+  var a = [];
+  for (let j=0;j<5;++j) a.push(0 | ((0x60000009) * 0x60000009));
+  return a.join(",");
+}
+testMulOverflow.expected = "-1073741824,-1073741824,-1073741824,-1073741824,-1073741824";
+test(testMulOverflow);
+
+function testThinLoopDemote() {
+  function f()
+  {
+    var k = 1;
+    for (var n = 0; n < 4; n++) {
+      k = (k * 10);
+    }
+    return k;
+  }
+  f();
+  return f();
+}
+testThinLoopDemote.expected = 10000;
+testThinLoopDemote.jitstats = {
+recorderStarted: 2,
+recorderAborted: 0,
+traceCompleted: 2,
+traceTriggered: 2,
+unstableLoopVariable: 1
+};
+test(testThinLoopDemote);
+
+var global = this;
+function testWeirdDateParseOuter()
+{
+  var vDateParts = ["11", "17", "2008"];
+  var out = [];
+  for (var vI = 0; vI < vDateParts.length; vI++)
+    out.push(testWeirdDateParseInner(vDateParts[vI]));
+  /* Mutate the global shape so we fall off trace; this causes
+   * additional oddity */
+  global.x = Math.random();
+  return out;
+} 
+function testWeirdDateParseInner(pVal)
+{
+  var vR = 0;
+  for (var vI = 0; vI < pVal.length; vI++) {
+    var vC = pVal.charAt(vI);
+    if ((vC >= '0') && (vC <= '9'))
+            vR = (vR * 10) + parseInt(vC);
+  }
+  return vR;
+}
+function testWeirdDateParse() {
+  var result = [];
+  result.push(testWeirdDateParseInner("11"));
+  result.push(testWeirdDateParseInner("17"));
+  result.push(testWeirdDateParseInner("2008"));
+  result.push(testWeirdDateParseInner("11"));
+  result.push(testWeirdDateParseInner("17"));
+  result.push(testWeirdDateParseInner("2008"));
+  result = result.concat(testWeirdDateParseOuter());
+  result = result.concat(testWeirdDateParseOuter());
+  result.push(testWeirdDateParseInner("11"));
+  result.push(testWeirdDateParseInner("17"));
+  result.push(testWeirdDateParseInner("2008"));
+  return result.join(",");
+}
+testWeirdDateParse.expected = "11,17,2008,11,17,2008,11,17,2008,11,17,2008,11,17,2008";
+testWeirdDateParse.jitstats = {
+recorderStarted: 8,
+recorderAborted: 1,
+traceCompleted: 7,
+traceTriggered: 14,
+unstableLoopVariable: 3,
+noCompatInnerTrees: 1
+};
+test(testWeirdDateParse);
+
+function testUndemotableBinaryOp() {
+  var out = [];
+  for (let j = 0; j < 5; ++j) { out.push(6 - ((void 0) ^ 0x80000005)); }
+  return out.join(",");
+}
+testUndemotableBinaryOp.expected = "2147483649,2147483649,2147483649,2147483649,2147483649";
+test(testUndemotableBinaryOp);
+
+function testNullRelCmp() {
+  var out = [];
+  for(j=0;j<3;++j) { out.push(3 > null); out.push(3 < null); out.push(0 == null); out.push(3 == null); }
+  return out.join(",");
+}
+testNullRelCmp.expected = "true,false,false,false,true,false,false,false,true,false,false,false";
+test(testNullRelCmp);
+
+function testEqFalseEmptyString() {
+  var x = [];
+  for (var i=0;i<5;++i) x.push(false == "");
+  return x.join(",");
+}
+testEqFalseEmptyString.expected = "true,true,true,true,true";
+test(testEqFalseEmptyString);
+
+function testIncDec2(ii) {
+  var x = [];
+  for (let j=0;j<5;++j) { 
+    ii=j;
+    jj=j; 
+    var kk=j; 
+    x.push(ii--);
+    x.push(jj--); 
+    x.push(kk--); 
+    x.push(++ii);
+    x.push(++jj); 
+    x.push(++kk); 
+  }
+  return x.join(",");
+}
+function testIncDec() {
+  return testIncDec2(0);
+}
+testIncDec.expected = "0,0,0,0,0,0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,4,4";
+test(testIncDec);
+
+function testApply() {
+    var q = [];
+    for (var i = 0; i < 10; ++i)
+        Array.prototype.push.apply(q, [5]);
+    return q.join(",");
+}
+testApply.expected = "5,5,5,5,5,5,5,5,5,5";
+test(testApply);
+
+function testNestedForIn() {
+    var a = {x: 1, y: 2, z: 3};
+    var s = '';
+    for (var p1 in a)
+        for (var p2 in a)
+            s += p1 + p2 + ' ';
+    return s;
+}
+testNestedForIn.expected = 'xx xy xz yx yy yz zx zy zz ';
+test(testNestedForIn);
+
+function testForEach() {
+    var r;
+    var a = ["zero", "one", "two", "three"];
+    for (var i = 0; i < RUNLOOP; i++) {
+        r = "";
+        for each (var s in a)
+            r += s + " ";
+    }
+    return r;
+}
+testForEach.expected = "zero one two three ";
+test(testForEach);
+
+function testThinForEach() {
+    var a = ["red"];
+    var n = 0;
+    for (var i = 0; i < 10; i++)
+        for each (var v in a)
+            if (v)
+                n++;
+    return n;
+}
+testThinForEach.expected = 10;
+test(testThinForEach);
+
+function testComparisons()
+{
+  // All the special values from each of the types in
+  // ECMA-262, 3rd ed. section 8
+  var undefinedType, nullType, booleanType, stringType, numberType, objectType;
+
+  var types = [];
+  types[undefinedType = 0] = "Undefined";
+  types[nullType = 1] = "Null";
+  types[booleanType = 2] = "Boolean";
+  types[stringType = 3] = "String";
+  types[numberType = 4] = "Number";
+  types[objectType = 5] = "Object";
+
+  var JSVAL_INT_MIN = -Math.pow(2, 30);
+  var JSVAL_INT_MAX = Math.pow(2, 30) - 1;
+
+  // Values from every ES3 type, hitting all the edge-case and special values
+  // that can be dreamed up
+  var values =
+    {
+     "undefined":
+       {
+         value: function() { return undefined; },
+         type: undefinedType
+       },
+     "null":
+       {
+         value: function() { return null; },
+         type: nullType
+       },
+     "true":
+       {
+         value: function() { return true; },
+         type: booleanType
+       },
+     "false":
+       {
+         value: function() { return false; },
+         type: booleanType
+       },
+     '""':
+       {
+         value: function() { return ""; },
+         type: stringType
+       },
+     '"a"':
+       {
+         // a > [, for string-object comparisons
+         value: function() { return "a"; },
+         type: stringType
+       },
+     '"Z"':
+       {
+         // Z < [, for string-object comparisons
+         value: function() { return "Z"; },
+         type: stringType
+       },
+     "0":
+       {
+         value: function() { return 0; },
+         type: numberType
+       },
+     "-0":
+       {
+         value: function() { return -0; },
+         type: numberType
+       },
+     "1":
+       {
+         value: function() { return 1; },
+         type: numberType
+       },
+     "Math.E":
+       {
+         value: function() { return Math.E; },
+         type: numberType
+       },
+     "JSVAL_INT_MIN - 1":
+       {
+         value: function() { return JSVAL_INT_MIN - 1; },
+         type: numberType
+       },
+     "JSVAL_INT_MIN":
+       {
+         value: function() { return JSVAL_INT_MIN; },
+         type: numberType
+       },
+     "JSVAL_INT_MIN + 1":
+       {
+         value: function() { return JSVAL_INT_MIN + 1; },
+         type: numberType
+       },
+     "JSVAL_INT_MAX - 1":
+       {
+         value: function() { return JSVAL_INT_MAX - 1; },
+         type: numberType
+       },
+     "JSVAL_INT_MAX":
+       {
+         value: function() { return JSVAL_INT_MAX; },
+         type: numberType
+       },
+     "JSVAL_INT_MAX + 1":
+       {
+         value: function() { return JSVAL_INT_MAX + 1; },
+         type: numberType
+       },
+     "Infinity":
+       {
+         value: function() { return Infinity; },
+         type: numberType
+       },
+     "-Infinity":
+       {
+         value: function() { return -Infinity; },
+         type: numberType
+       },
+     "NaN":
+       {
+         value: function() { return NaN; },
+         type: numberType
+       },
+     "{}":
+       {
+         value: function() { return {}; },
+         type: objectType
+       },
+     "{ valueOf: undefined }":
+       {
+         value: function() { return { valueOf: undefined }; },
+         type: objectType
+       },
+     "[]":
+       {
+         value: function() { return []; },
+         type: objectType
+       },
+     '[""]':
+       {
+         value: function() { return [""]; },
+         type: objectType
+       },
+     '["a"]':
+       {
+         value: function() { return ["a"]; },
+         type: objectType
+       },
+     "[0]":
+       {
+         value: function() { return [0]; },
+         type: objectType
+       }
+    };
+
+  var orderOps =
+    {
+     "<": function(a, b) { return a < b; },
+     ">": function(a, b) { return a > b; },
+     "<=": function(a, b) { return a <= b; },
+     ">=": function(a, b) { return a >= b; }
+    };
+  var eqOps =
+    {
+     "==": function(a, b) { return a == b; },
+     "!=": function(a, b) { return a != b; },
+     "===": function(a, b) { return a === b; },
+     "!==": function(a, b) { return a !== b; }
+    };
+
+
+  var notEqualIncomparable =
+    {
+      eq: { "==": false, "!=": true, "===": false, "!==": true },
+      order: { "<": false, ">": false, "<=": false, ">=": false }
+    };
+  var notEqualLessThan =
+    {
+      eq: { "==": false, "!=": true, "===": false, "!==": true },
+      order: { "<": true, ">": false, "<=": true, ">=": false }
+    };
+  var notEqualGreaterThan =
+    {
+      eq: { "==": false, "!=": true, "===": false, "!==": true },
+      order: { "<": false, ">": true, "<=": false, ">=": true }
+    };
+  var notEqualNorDifferent =
+    {
+      eq: { "==": false, "!=": true, "===": false, "!==": true },
+      order: { "<": false, ">": false, "<=": true, ">=": true }
+    };
+  var strictlyEqual =
+    {
+      eq: { "==": true, "!=": false, "===": true, "!==": false },
+      order: { "<": false, ">": false, "<=": true, ">=": true }
+    };
+  var looselyEqual =
+    {
+      eq: { "==": true, "!=": false, "===": false, "!==": true },
+      order: { "<": false, ">": false, "<=": true, ">=": true }
+    };
+  var looselyEqualNotDifferent =
+    {
+      eq: { "==": true, "!=": false, "===": false, "!==": true },
+      order: { "<": false, ">": false, "<=": true, ">=": true }
+    };
+  var looselyEqualIncomparable =
+    {
+      eq: { "==": true, "!=": false, "===": false, "!==": true },
+      order: { "<": false, ">": false, "<=": false, ">=": false }
+    };
+  var strictlyEqualNotDifferent =
+    {
+      eq: { "==": true, "!=": false, "===": true, "!==": false },
+      order: { "<": false, ">": false, "<=": true, ">=": true }
+    };
+  var strictlyEqualIncomparable =
+    {
+      eq: { "==": true, "!=": false, "===": true, "!==": false },
+      order: { "<": false, ">": false, "<=": false, ">=": false }
+    };
+
+  var comparingZeroToSomething =
+    {
+      "undefined": notEqualIncomparable,
+      "null": notEqualNorDifferent,
+      "true": notEqualLessThan,
+      "false": looselyEqual,
+      '""': looselyEqualNotDifferent,
+      '"a"': notEqualIncomparable,
+      '"Z"': notEqualIncomparable,
+      "0": strictlyEqual,
+      "-0": strictlyEqual,
+      "1": notEqualLessThan,
+      "Math.E": notEqualLessThan,
+      "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+      "JSVAL_INT_MIN": notEqualGreaterThan,
+      "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+      "JSVAL_INT_MAX - 1": notEqualLessThan,
+      "JSVAL_INT_MAX": notEqualLessThan,
+      "JSVAL_INT_MAX + 1": notEqualLessThan,
+      "Infinity": notEqualLessThan,
+      "-Infinity": notEqualGreaterThan,
+      "NaN": notEqualIncomparable,
+      "{}": notEqualIncomparable,
+      "{ valueOf: undefined }": notEqualIncomparable,
+      "[]": looselyEqual,
+      '[""]': looselyEqual,
+      '["a"]': notEqualIncomparable,
+      "[0]": looselyEqual
+    };
+
+  var comparingObjectOrObjectWithValueUndefined =
+    {
+      "undefined": notEqualIncomparable,
+      "null": notEqualIncomparable,
+      "true": notEqualIncomparable,
+      "false": notEqualIncomparable,
+      '""': notEqualGreaterThan,
+      '"a"': notEqualLessThan,
+      '"Z"': notEqualGreaterThan,
+      "0": notEqualIncomparable,
+      "-0": notEqualIncomparable,
+      "1": notEqualIncomparable,
+      "Math.E": notEqualIncomparable,
+      "JSVAL_INT_MIN - 1": notEqualIncomparable,
+      "JSVAL_INT_MIN": notEqualIncomparable,
+      "JSVAL_INT_MIN + 1": notEqualIncomparable,
+      "JSVAL_INT_MAX - 1": notEqualIncomparable,
+      "JSVAL_INT_MAX": notEqualIncomparable,
+      "JSVAL_INT_MAX + 1": notEqualIncomparable,
+      "Infinity": notEqualIncomparable,
+      "-Infinity": notEqualIncomparable,
+      "NaN": notEqualIncomparable,
+      "{}": notEqualNorDifferent,
+      "{ valueOf: undefined }": notEqualNorDifferent,
+      "[]": notEqualGreaterThan,
+      '[""]': notEqualGreaterThan,
+      '["a"]': notEqualLessThan,
+      "[0]": notEqualGreaterThan
+    };
+
+  // Constructed expected-value matrix
+  var expected =
+    {
+     "undefined":
+       {
+         "undefined": strictlyEqualIncomparable,
+         "null": looselyEqualIncomparable,
+         "true": notEqualIncomparable,
+         "false": notEqualIncomparable,
+         '""': notEqualIncomparable,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualIncomparable,
+         "-0": notEqualIncomparable,
+         "1": notEqualIncomparable,
+         "Math.E": notEqualIncomparable,
+         "JSVAL_INT_MIN - 1": notEqualIncomparable,
+         "JSVAL_INT_MIN": notEqualIncomparable,
+         "JSVAL_INT_MIN + 1": notEqualIncomparable,
+         "JSVAL_INT_MAX - 1": notEqualIncomparable,
+         "JSVAL_INT_MAX": notEqualIncomparable,
+         "JSVAL_INT_MAX + 1": notEqualIncomparable,
+         "Infinity": notEqualIncomparable,
+         "-Infinity": notEqualIncomparable,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualIncomparable,
+         '[""]': notEqualIncomparable,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualIncomparable
+       },
+     "null":
+       {
+         "undefined": looselyEqualIncomparable,
+         "null": strictlyEqualNotDifferent,
+         "true": notEqualLessThan,
+         "false": notEqualNorDifferent,
+         '""': notEqualNorDifferent,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualNorDifferent,
+         "-0": notEqualNorDifferent,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualNorDifferent,
+         '[""]': notEqualNorDifferent,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualNorDifferent
+       },
+     "true":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": strictlyEqual,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": looselyEqual,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "false":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualNorDifferent,
+         "true": notEqualLessThan,
+         "false": strictlyEqual,
+         '""': looselyEqualNotDifferent,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": looselyEqual,
+         "-0": looselyEqual,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": looselyEqual,
+         '[""]': looselyEqual,
+         '["a"]': notEqualIncomparable,
+         "[0]": looselyEqual
+       },
+     '""':
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualNorDifferent,
+         "true": notEqualLessThan,
+         "false": looselyEqual,
+         '""': strictlyEqual,
+         '"a"': notEqualLessThan,
+         '"Z"': notEqualLessThan,
+         "0": looselyEqual,
+         "-0": looselyEqual,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualLessThan,
+         "{ valueOf: undefined }": notEqualLessThan,
+         "[]": looselyEqual,
+         '[""]': looselyEqual,
+         '["a"]': notEqualLessThan,
+         "[0]": notEqualLessThan
+       },
+     '"a"':
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualIncomparable,
+         "true": notEqualIncomparable,
+         "false": notEqualIncomparable,
+         '""': notEqualGreaterThan,
+         '"a"': strictlyEqual,
+         '"Z"': notEqualGreaterThan,
+         "0": notEqualIncomparable,
+         "-0": notEqualIncomparable,
+         "1": notEqualIncomparable,
+         "Math.E": notEqualIncomparable,
+         "JSVAL_INT_MIN - 1": notEqualIncomparable,
+         "JSVAL_INT_MIN": notEqualIncomparable,
+         "JSVAL_INT_MIN + 1": notEqualIncomparable,
+         "JSVAL_INT_MAX - 1": notEqualIncomparable,
+         "JSVAL_INT_MAX": notEqualIncomparable,
+         "JSVAL_INT_MAX + 1": notEqualIncomparable,
+         "Infinity": notEqualIncomparable,
+         "-Infinity": notEqualIncomparable,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualGreaterThan,
+         "{ valueOf: undefined }": notEqualGreaterThan,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': looselyEqualNotDifferent,
+         "[0]": notEqualGreaterThan
+       },
+     '"Z"':
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualIncomparable,
+         "true": notEqualIncomparable,
+         "false": notEqualIncomparable,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualLessThan,
+         '"Z"': strictlyEqual,
+         "0": notEqualIncomparable,
+         "-0": notEqualIncomparable,
+         "1": notEqualIncomparable,
+         "Math.E": notEqualIncomparable,
+         "JSVAL_INT_MIN - 1": notEqualIncomparable,
+         "JSVAL_INT_MIN": notEqualIncomparable,
+         "JSVAL_INT_MIN + 1": notEqualIncomparable,
+         "JSVAL_INT_MAX - 1": notEqualIncomparable,
+         "JSVAL_INT_MAX": notEqualIncomparable,
+         "JSVAL_INT_MAX + 1": notEqualIncomparable,
+         "Infinity": notEqualIncomparable,
+         "-Infinity": notEqualIncomparable,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualLessThan,
+         "{ valueOf: undefined }": notEqualLessThan,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualLessThan,
+         "[0]": notEqualGreaterThan
+       },
+     "0": comparingZeroToSomething,
+     "-0": comparingZeroToSomething,
+     "1":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": looselyEqual,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": strictlyEqual,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "Math.E":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": notEqualGreaterThan,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": notEqualGreaterThan,
+         "Math.E": strictlyEqual,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "JSVAL_INT_MIN - 1":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualLessThan,
+         "true": notEqualLessThan,
+         "false": notEqualLessThan,
+         '""': notEqualLessThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualLessThan,
+         "-0": notEqualLessThan,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": strictlyEqual,
+         "JSVAL_INT_MIN": notEqualLessThan,
+         "JSVAL_INT_MIN + 1": notEqualLessThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualLessThan,
+         '[""]': notEqualLessThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualLessThan
+       },
+     "JSVAL_INT_MIN":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualLessThan,
+         "true": notEqualLessThan,
+         "false": notEqualLessThan,
+         '""': notEqualLessThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualLessThan,
+         "-0": notEqualLessThan,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": strictlyEqual,
+         "JSVAL_INT_MIN + 1": notEqualLessThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualLessThan,
+         '[""]': notEqualLessThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualLessThan
+       },
+     "JSVAL_INT_MIN + 1":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualLessThan,
+         "true": notEqualLessThan,
+         "false": notEqualLessThan,
+         '""': notEqualLessThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualLessThan,
+         "-0": notEqualLessThan,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": strictlyEqual,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualLessThan,
+         '[""]': notEqualLessThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualLessThan
+       },
+     "JSVAL_INT_MAX - 1":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": notEqualGreaterThan,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": notEqualGreaterThan,
+         "Math.E": notEqualGreaterThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": strictlyEqual,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "JSVAL_INT_MAX":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": notEqualGreaterThan,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": notEqualGreaterThan,
+         "Math.E": notEqualGreaterThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX": strictlyEqual,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "JSVAL_INT_MAX + 1":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": notEqualGreaterThan,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": notEqualGreaterThan,
+         "Math.E": notEqualGreaterThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX": notEqualGreaterThan,
+         "JSVAL_INT_MAX + 1": strictlyEqual,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "Infinity":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualGreaterThan,
+         "true": notEqualGreaterThan,
+         "false": notEqualGreaterThan,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualGreaterThan,
+         "-0": notEqualGreaterThan,
+         "1": notEqualGreaterThan,
+         "Math.E": notEqualGreaterThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX": notEqualGreaterThan,
+         "JSVAL_INT_MAX + 1": notEqualGreaterThan,
+         "Infinity": strictlyEqual,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualGreaterThan
+       },
+     "-Infinity":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualLessThan,
+         "true": notEqualLessThan,
+         "false": notEqualLessThan,
+         '""': notEqualLessThan,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualLessThan,
+         "-0": notEqualLessThan,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualLessThan,
+         "JSVAL_INT_MIN": notEqualLessThan,
+         "JSVAL_INT_MIN + 1": notEqualLessThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": strictlyEqual,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualLessThan,
+         '[""]': notEqualLessThan,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualLessThan
+       },
+     "NaN":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualIncomparable,
+         "true": notEqualIncomparable,
+         "false": notEqualIncomparable,
+         '""': notEqualIncomparable,
+         '"a"': notEqualIncomparable,
+         '"Z"': notEqualIncomparable,
+         "0": notEqualIncomparable,
+         "-0": notEqualIncomparable,
+         "1": notEqualIncomparable,
+         "Math.E": notEqualIncomparable,
+         "JSVAL_INT_MIN - 1": notEqualIncomparable,
+         "JSVAL_INT_MIN": notEqualIncomparable,
+         "JSVAL_INT_MIN + 1": notEqualIncomparable,
+         "JSVAL_INT_MAX - 1": notEqualIncomparable,
+         "JSVAL_INT_MAX": notEqualIncomparable,
+         "JSVAL_INT_MAX + 1": notEqualIncomparable,
+         "Infinity": notEqualIncomparable,
+         "-Infinity": notEqualIncomparable,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualIncomparable,
+         "{ valueOf: undefined }": notEqualIncomparable,
+         "[]": notEqualIncomparable,
+         '[""]': notEqualIncomparable,
+         '["a"]': notEqualIncomparable,
+         "[0]": notEqualIncomparable
+       },
+     "{}": comparingObjectOrObjectWithValueUndefined,
+     "{ valueOf: undefined }": comparingObjectOrObjectWithValueUndefined,
+     "[]":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualNorDifferent,
+         "true": notEqualLessThan,
+         "false": looselyEqual,
+         '""': looselyEqual,
+         '"a"': notEqualLessThan,
+         '"Z"': notEqualLessThan,
+         "0": looselyEqual,
+         "-0": looselyEqual,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualLessThan,
+         "{ valueOf: undefined }": notEqualLessThan,
+         "[]": notEqualNorDifferent,
+         '[""]': notEqualNorDifferent,
+         '["a"]': notEqualLessThan,
+         "[0]": notEqualLessThan
+       },
+     '[""]':
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualNorDifferent,
+         "true": notEqualLessThan,
+         "false": looselyEqual,
+         '""': looselyEqual,
+         '"a"': notEqualLessThan,
+         '"Z"': notEqualLessThan,
+         "0": looselyEqual,
+         "-0": looselyEqual,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualLessThan,
+         "{ valueOf: undefined }": notEqualLessThan,
+         "[]": notEqualNorDifferent,
+         '[""]': notEqualNorDifferent,
+         '["a"]': notEqualLessThan,
+         "[0]": notEqualLessThan
+       },
+     '["a"]':
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualIncomparable,
+         "true": notEqualIncomparable,
+         "false": notEqualIncomparable,
+         '""': notEqualGreaterThan,
+         '"a"': looselyEqual,
+         '"Z"': notEqualGreaterThan,
+         "0": notEqualIncomparable,
+         "-0": notEqualIncomparable,
+         "1": notEqualIncomparable,
+         "Math.E": notEqualIncomparable,
+         "JSVAL_INT_MIN - 1": notEqualIncomparable,
+         "JSVAL_INT_MIN": notEqualIncomparable,
+         "JSVAL_INT_MIN + 1": notEqualIncomparable,
+         "JSVAL_INT_MAX - 1": notEqualIncomparable,
+         "JSVAL_INT_MAX": notEqualIncomparable,
+         "JSVAL_INT_MAX + 1": notEqualIncomparable,
+         "Infinity": notEqualIncomparable,
+         "-Infinity": notEqualIncomparable,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualGreaterThan,
+         "{ valueOf: undefined }": notEqualGreaterThan,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualNorDifferent,
+         "[0]": notEqualGreaterThan
+       },
+     "[0]":
+       {
+         "undefined": notEqualIncomparable,
+         "null": notEqualNorDifferent,
+         "true": notEqualLessThan,
+         "false": looselyEqual,
+         '""': notEqualGreaterThan,
+         '"a"': notEqualLessThan,
+         '"Z"': notEqualLessThan,
+         "0": looselyEqual,
+         "-0": looselyEqual,
+         "1": notEqualLessThan,
+         "Math.E": notEqualLessThan,
+         "JSVAL_INT_MIN - 1": notEqualGreaterThan,
+         "JSVAL_INT_MIN": notEqualGreaterThan,
+         "JSVAL_INT_MIN + 1": notEqualGreaterThan,
+         "JSVAL_INT_MAX - 1": notEqualLessThan,
+         "JSVAL_INT_MAX": notEqualLessThan,
+         "JSVAL_INT_MAX + 1": notEqualLessThan,
+         "Infinity": notEqualLessThan,
+         "-Infinity": notEqualGreaterThan,
+         "NaN": notEqualIncomparable,
+         "{}": notEqualLessThan,
+         "{ valueOf: undefined }": notEqualLessThan,
+         "[]": notEqualGreaterThan,
+         '[""]': notEqualGreaterThan,
+         '["a"]': notEqualLessThan,
+         "[0]": notEqualNorDifferent
+       }
+    };
+
+
+
+  var failures = [];
+  function fail(a, ta, b, tb, ex, ac, op)
+  {
+    failures.push("(" + a + " " + op + " " + b + ") wrong: " +
+                  "expected " + ex + ", got " + ac +
+                  " (types " + types[ta] + ", " + types[tb] + ")");
+  }
+
+  var result = false;
+  for (var i in values)
+  {
+    for (var j in values)
+    {
+      // Constants, so hoist to help JIT know that
+      var vala = values[i], valb = values[j];
+      var a = vala.value(), b = valb.value();
+
+      for (var opname in orderOps)
+      {
+        var op = orderOps[opname];
+        var expect = expected[i][j].order[opname];
+        var failed = false;
+
+        for (var iter = 0; iter < 5; iter++)
+        {
+          result = op(a, b);
+          failed = failed || result !== expect;
+        }
+
+        if (failed)
+          fail(i, vala.type, j, valb.type, expect, result, opname);
+      }
+
+      for (var opname in eqOps)
+      {
+        var op = eqOps[opname];
+        var expect = expected[i][j].eq[opname];
+        var failed = false;
+
+        for (var iter = 0; iter < 5; iter++)
+        {
+          result = op(a, b);
+          failed = failed || result !== expect;
+        }
+
+        if (failed)
+          fail(i, vala.type, j, valb.type, expect, result, opname);
+      }
+    }
+  }
+
+  if (failures.length == 0)
+    return "no failures reported!";
+
+  return "\n" + failures.join(",\n");
+}
+testComparisons.expected = "no failures reported!";
+test(testComparisons);
+
+function testCaseAbort()
+{
+  var four = "4";
+  var r = 0;
+  for (var i = 0; i < 5; i++)
+  {
+    switch (i)
+    {
+      case four: r += 1; break;
+      default: r += 2; break;
+    }
+  }
+
+  return "" + r;
+}
+testCaseAbort.expected = "10";
+testCaseAbort.jitstats = {
+  recorderAborted: 0
+};
+test(testCaseAbort);
+
+function testApplyCallHelper(f) {
+    var r = [];
+    for (var i = 0; i < 10; ++i) f.call();
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this,0);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this,[0]);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this,0,1);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this,[0,1]);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this,0,1,2);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this,[0,1,2]);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this,0,1,2,3);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this,[0,1,2,3]);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this,0,1,2,3,4);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this,[0,1,2,3,4]);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.call(this,0,1,2,3,4,5);
+    r.push(x);
+    for (var i = 0; i < 10; ++i) f.apply(this,[0,1,2,3,4,5])
+    r.push(x);
+    return(r.join(","));
+}
+function testApplyCall() {
+    var r = testApplyCallHelper(function (a0,a1,a2,a3,a4,a5,a6,a7) { x = [a0,a1,a2,a3,a4,a5,a6,a7]; });
+    r += testApplyCallHelper(function (a0,a1,a2,a3,a4,a5,a6,a7) { x = [a0,a1,a2,a3,a4,a5,a6,a7]; });
+    return r;
+}
+testApplyCall.expected =
+",,,,,,,,,,,,,,,,,,,,,,,,0,,,,,,,,0,,,,,,,,0,1,,,,,,,0,1,,,,,,,0,1,2,,,,,,0,1,2,,,,,,0,1,2,3,,,,,0,1,2,3,,,,,0,1,2,3,4,,,,0,1,2,3,4,,,,0,1,2,3,4,5,,,0,1,2,3,4,5,," +
+",,,,,,,,,,,,,,,,,,,,,,,,0,,,,,,,,0,,,,,,,,0,1,,,,,,,0,1,,,,,,,0,1,2,,,,,,0,1,2,,,,,,0,1,2,3,,,,,0,1,2,3,,,,,0,1,2,3,4,,,,0,1,2,3,4,,,,0,1,2,3,4,5,,,0,1,2,3,4,5,,";
+test(testApplyCall);
+
+function testApplyUnboxHelper(f,a) {
+    var q;
+    for (var i = 0; i < 10; ++i)
+        q = f.apply(f,a);
+    return q;
+}
+function testApplyUnbox() {
+    var f = function(x) { return x; }
+    return [testApplyUnboxHelper(f,[1]), testApplyUnboxHelper(f,[true])].join(",");
+}
+testApplyUnbox.expected = "1,true";
+test(testApplyUnbox);
+
+function testCallPick() {
+    function g(x,a) {
+        x.f();
+    }
+
+    var x = [];
+    x.f = function() { }
+
+    var y = [];
+    y.f = function() { }
+
+    var z = [x,x,x,x,x,y,y,y,y,y];
+
+    for (var i = 0; i < 10; ++i)
+        g.call(this, z[i], "");
+    return true;
+}
+testCallPick.expected = true;
+test(testCallPick);
+
+function testInvertNullAfterNegateNull()
+{
+  for (var i = 0; i < 5; i++) !null;
+  for (var i = 0; i < 5; i++) -null;
+  return "no assertion";
+}
+testInvertNullAfterNegateNull.expected = "no assertion";
+test(testInvertNullAfterNegateNull);
+
+function testUnaryImacros()
+{
+  function checkArg(x)
+  {
+    return 1;
+  }
+
+  var o = { valueOf: checkArg, toString: null };
+  var count = 0;
+  var v = 0;
+  for (var i = 0; i < 5; i++)
+    v += +o + -(-o);
+
+  var results = [v === 10 ? "valueOf passed" : "valueOf failed"];
+
+  o.valueOf = null;
+  o.toString = checkArg;
+
+  for (var i = 0; i < 5; i++)
+    v += +o + -(-o);
+
+  results.push(v === 20 ? "toString passed" : "toString failed");
+
+  return results.join(", ");
+}
+testUnaryImacros.expected = "valueOf passed, toString passed";
+test(testUnaryImacros);
+
+function testAddAnyInconvertibleObject()
+{
+  var count = 0;
+  function toString() { ++count; if (count == 95) return {}; return "" + count; }
+
+  var threw = false;
+  try
+  {
+    for (var i = 0; i < 100; i++)
+    {
+        var o = {valueOf: undefined, toString: toString};
+        var q = 5 + o;
+    }
+  }
+  catch (e)
+  {
+    threw = true;
+    if (i !== 94)
+      return "expected i === 94, got " + i;
+    if (q !== "594")
+      return "expected q === '594', got " + q + " (type " + typeof q + ")";
+    if (count !== 95)
+      return "expected count === 95, got " + count;
+  }
+  if (!threw)
+    return "expected throw with 5 + o"; // hey, a rhyme!
+
+  return "pass";
+}
+testAddAnyInconvertibleObject.expected = "pass";
+testAddAnyInconvertibleObject.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 93
+};
+test(testAddAnyInconvertibleObject);
+
+function testAddInconvertibleObjectAny()
+{
+  var count = 0;
+  function toString() 
+  { 
+      ++count; 
+      if (count == 95) 
+          return {}; 
+      return "" + count;
+  }
+
+  var threw = false;
+  try
+  {
+    for (var i = 0; i < 100; i++)
+    {
+        var o = {valueOf: undefined, toString: toString};
+        var q = o + 5;
+    }
+  }
+  catch (e)
+  {
+    threw = true;
+    if (i !== 94)
+      return "expected i === 94, got " + i;
+    if (q !== "945")
+      return "expected q === '945', got " + q + " (type " + typeof q + ")";
+    if (count !== 95)
+      return "expected count === 95, got " + count;
+  }
+  if (!threw)
+    return "expected throw with o + 5";
+
+  return "pass";
+}
+testAddInconvertibleObjectAny.expected = "pass";
+testAddInconvertibleObjectAny.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 93
+};
+test(testAddInconvertibleObjectAny);
+
+function testAddInconvertibleObjectInconvertibleObject()
+{
+  var count1 = 0;
+  function toString1() { ++count1; if (count1 == 95) return {}; return "" + count1; }
+  var count2 = 0;
+  function toString2() { ++count2; if (count2 == 95) return {}; return "" + count2; }
+
+  var threw = false;
+  try
+  {
+    for (var i = 0; i < 100; i++)
+    {
+        var o1 = {valueOf: undefined, toString: toString1};
+        var o2 = {valueOf: undefined, toString: toString2};
+        var q = o1 + o2;
+    }
+  }
+  catch (e)
+  {
+    threw = true;
+    if (i !== 94)
+      return "expected i === 94, got " + i;
+    if (q !== "9494")
+      return "expected q === '9494', got " + q + " (type " + typeof q + ")";
+    if (count1 !== 95)
+      return "expected count1 === 95, got " + count1;
+    if (count2 !== 94)
+      return "expected count2 === 94, got " + count2;
+  }
+  if (!threw)
+    return "expected throw with o1 + o2";
+
+  return "pass";
+}
+testAddInconvertibleObjectInconvertibleObject.expected = "pass";
+testAddInconvertibleObjectInconvertibleObject.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 93
+};
+test(testAddInconvertibleObjectInconvertibleObject);
+
+function testBitOrAnyInconvertibleObject()
+{
+  var count = 0;
+  function toString() { ++count; if (count == 95) return {}; return count; }
+
+  var threw = false;
+  try
+  {
+    for (var i = 0; i < 100; i++)
+    {
+        var o = {valueOf: undefined, toString: toString};
+        var q = 1 | o;
+    }
+  }
+  catch (e)
+  {
+    threw = true;
+    if (i !== 94)
+      return "expected i === 94, got " + i;
+    if (q !== 95)
+      return "expected q === 95, got " + q;
+    if (count !== 95)
+      return "expected count === 95, got " + count;
+  }
+  if (!threw)
+    return "expected throw with 2 | o"; // hey, a rhyme!
+
+  return "pass";
+}
+testBitOrAnyInconvertibleObject.expected = "pass";
+testBitOrAnyInconvertibleObject.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 93
+};
+test(testBitOrAnyInconvertibleObject);
+
+function testBitOrInconvertibleObjectAny()
+{
+  var count = 0;
+  function toString() { ++count; if (count == 95) return {}; return count; }
+
+  var threw = false;
+  try
+  {
+    for (var i = 0; i < 100; i++)
+    {
+        var o = {valueOf: undefined, toString: toString};
+        var q = o | 1;
+    }
+  }
+  catch (e)
+  {
+    threw = true;
+    if (i !== 94)
+      return "expected i === 94, got " + i;
+    if (q !== 95)
+      return "expected q === 95, got " + q;
+    if (count !== 95)
+      return "expected count === 95, got " + count;
+  }
+  if (!threw)
+    return "expected throw with o | 2";
+
+  return "pass";
+}
+testBitOrInconvertibleObjectAny.expected = "pass";
+testBitOrInconvertibleObjectAny.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 93
+};
+test(testBitOrInconvertibleObjectAny);
+
+function testBitOrInconvertibleObjectInconvertibleObject()
+{
+  var count1 = 0;
+  function toString1() { ++count1; if (count1 == 95) return {}; return count1; }
+  var count2 = 0;
+  function toString2() { ++count2; if (count2 == 95) return {}; return count2; }
+
+  var threw = false;
+  try
+  {
+    for (var i = 0; i < 100; i++)
+    {
+        var o1 = {valueOf: undefined, toString: toString1};
+        var o2 = {valueOf: undefined, toString: toString2};
+        var q = o1 | o2;
+    }
+  }
+  catch (e)
+  {
+    threw = true;
+    if (i !== 94)
+      return "expected i === 94, got " + i;
+    if (q !== 94)
+      return "expected q === 94, got " + q;
+    if (count1 !== 95)
+      return "expected count1 === 95, got " + count1;
+    if (count2 !== 94)
+      return "expected count2 === 94, got " + count2;
+  }
+  if (!threw)
+    return "expected throw with o1 | o2";
+
+  return "pass";
+}
+testBitOrInconvertibleObjectInconvertibleObject.expected = "pass";
+testBitOrInconvertibleObjectInconvertibleObject.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 93
+};
+test(testBitOrInconvertibleObjectInconvertibleObject);
+
+function testCaseTypeMismatchBadness()
+{
+  for (var z = 0; z < 3; ++z)
+  {
+    switch ("")
+    {
+      default:
+      case 9:
+        break;
+
+      case "":
+      case <x/>:
+        break;
+    }
+  }
+
+  return "no crash";
+}
+testCaseTypeMismatchBadness.expected = "no crash";
+testCaseTypeMismatchBadness.jitstats = {
+    recorderAborted: 0
+};
+test(testCaseTypeMismatchBadness);
+
+function testDoubleComparison()
+{
+  for (var i = 0; i < 500000; ++i)
+  {
+    switch (1 / 0)
+    {
+      case Infinity:
+    }
+  }
+
+  return "finished";
+}
+testDoubleComparison.expected = "finished";
+testDoubleComparison.jitstats = {
+  sideExitIntoInterpreter: 1
+};
+test(testDoubleComparison);
+
+function testLirBufOOM()
+{
+    var a = [
+             "12345678901234",
+             "123456789012",
+             "1234567890123456789012345678",
+             "12345678901234567890123456789012345678901234567890123456",
+             "f",
+             "$",
+             "",
+             "f()",
+             "(\\*)",
+             "b()",
+             "()",
+             "(#)",
+             "ABCDEFGHIJK",
+             "ABCDEFGHIJKLM",
+             "ABCDEFGHIJKLMNOPQ",
+             "ABCDEFGH",
+             "(.)",
+             "(|)",
+             "()$",
+             "/()",
+             "(.)$"
+             ];
+    
+    for (var j = 0; j < 200; ++j) {
+        var js = "" + j;
+        for (var i = 0; i < a.length; i++)
+            "".match(a[i] + js)
+    }
+    return "ok";
+}
+testLirBufOOM.expected = "ok";
+test(testLirBufOOM);
+
+function testStringResolve() {
+    var x = 0;
+    for each (let d in [new String('q'), new String('q'), new String('q')]) {
+        if (("" + (0 in d)) === "true")
+            x++;
+    }
+    return x;
+}
+testStringResolve.expected = 3;
+test(testStringResolve);
+
+//test no multitrees assert
+function testGlobalMultitrees1() {
+    (function() { 
+      for (var j = 0; j < 4; ++j) {
+        for each (e in ['A', 1, 'A']) {
+        }
+      }
+    })();
+    return true;
+}
+testGlobalMultitrees1.expected = true;
+test(testGlobalMultitrees1);
+
+var q = [];
+for each (b in [0x3FFFFFFF, 0x3FFFFFFF, 0x3FFFFFFF]) {
+  for each (let e in [{}, {}, {}, "", {}]) { 
+    b = (b | 0x40000000) + 1;
+    q.push(b);
+  }
+}
+function testLetWithUnstableGlobal() {
+    return q.join(",");
+}
+testLetWithUnstableGlobal.expected = "2147483648,-1073741823,-1073741822,-1073741821,-1073741820,2147483648,-1073741823,-1073741822,-1073741821,-1073741820,2147483648,-1073741823,-1073741822,-1073741821,-1073741820";
+test(testLetWithUnstableGlobal);
+delete b;
+delete q;
+
+for each (testBug474769_b in [1, 1, 1, 1.5, 1, 1]) {
+    (function() { for each (let testBug474769_h in [0, 0, 1.4, ""]) {} })()
+}
+function testBug474769() {
+    return testBug474769_b;
+}
+testBug474769.expected = 1;
+test(testBug474769);
+
+function testReverseArgTypes() {
+    for (var j = 0; j < 4; ++j) ''.replace('', /x/);
+    return 1;
+}
+testReverseArgTypes.expected = 1;
+test(testReverseArgTypes);
+
+function testBug458838() {
+    var a = 1;
+    function g() {
+        var b = 0
+            for (var i = 0; i < 10; ++i) {
+                b += a;
+            }
+        return b;
+    }
+
+    return g();
+}
+testBug458838.expected = 10;
+testBug458838.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  traceCompleted: 1
+};
+test(testBug458838);
+
+function testInterpreterReentry() {
+    this.__defineSetter__('x', function(){})
+    for (var j = 0; j < 5; ++j) { x = 3; }
+    return 1;
+}
+testInterpreterReentry.expected = 1;
+test(testInterpreterReentry);
+
+function testInterpreterReentry2() {
+    var a = false;
+    var b = {};
+    var c = false;
+    var d = {};
+    this.__defineGetter__('e', function(){});
+    for (let f in this) print(f);
+    [1 for each (g in this) for each (h in [])]
+    return 1;
+}
+testInterpreterReentry2.expected = 1;
+test(testInterpreterReentry2);
+
+function testInterpreterReentry3() {
+    for (let i=0;i<5;++i) this["y" + i] = function(){};
+    this.__defineGetter__('e', function (x2) { yield; });
+    [1 for each (a in this) for (b in {})];
+    return 1;
+}
+testInterpreterReentry3.expected = 1;
+test(testInterpreterReentry3);
+
+function testInterpreterReentry4() {
+    var obj = {a:1, b:1, c:1, d:1, get e() 1000 };
+    for (var p in obj)
+        obj[p];
+}
+test(testInterpreterReentry4);
+
+function testInterpreterReentry5() {
+    var arr = [0, 1, 2, 3, 4];
+    arr.__defineGetter__("4", function() 1000);
+    for (var i = 0; i < 5; i++)
+        arr[i];
+    for (var p in arr)
+        arr[p];
+}
+test(testInterpreterReentry5);
+
+function testInterpreterReentry6() {
+    var obj = {a:1, b:1, c:1, d:1, set e(x) { this._e = x; }};
+    for (var p in obj)
+        obj[p] = "grue";
+    return obj._e;
+}
+testInterpreterReentry6.expected = "grue";
+test(testInterpreterReentry6);
+
+function testInterpreterReentry7() {
+    var arr = [0, 1, 2, 3, 4];
+    arr.__defineSetter__("4", function(x) { this._4 = x; });
+    for (var i = 0; i < 5; i++)
+        arr[i] = "grue";
+    var tmp = arr._4;
+    for (var p in arr)
+        arr[p] = "bleen";
+    return tmp + " " + arr._4;
+}
+testInterpreterReentry7.expected = "grue bleen";
+test(testInterpreterReentry7);
+
+// Bug 462027 comment 54.
+function testInterpreterReentery8() {
+    var e = <x><y/></x>;
+    for (var j = 0; j < 4; ++j) { +[e]; }
+}
+test(testInterpreterReentery8);
+
+function testHolePushing() {
+    var a = ["foobar", "baz"];
+    for (var i = 0; i < 5; i++)
+        a = [, "overwritten", "new"];
+    var s = "[";
+    for (i = 0; i < a.length; i++) {
+        s += (i in a) ? a[i] : "<hole>";
+        if (i != a.length - 1)
+            s += ",";
+    }
+    return s + "], " + (0 in a);
+}
+testHolePushing.expected = "[<hole>,overwritten,new], false";
+test(testHolePushing);
+
+function testDeepBail1() {
+    var y = <z/>;
+    for (var i = 0; i < RUNLOOP; i++)
+        "" in y;
+}
+test(testDeepBail1);
+
+/* Array comprehension tests */
+
+function Range(start, stop) {
+    this.i = start;
+    this.stop = stop;
+}
+Range.prototype = {
+    __iterator__: function() this,
+    next: function() {
+        if (this.i >= this.stop)
+            throw StopIteration;
+        return this.i++;
+    }
+};
+
+function range(start, stop) {
+    return new Range(start, stop);
+}
+
+function testArrayComp1() {
+    return [a for (a in range(0, 10))].join('');
+}
+testArrayComp1.expected='0123456789';
+test(testArrayComp1);
+
+function testArrayComp2() {
+    return [a + b for (a in range(0, 5)) for (b in range(0, 5))].join('');
+}
+testArrayComp2.expected='0123412345234563456745678';
+test(testArrayComp2);
+
+function testSwitchUndefined()
+{
+  var x = undefined;
+  var y = 0;
+  for (var i = 0; i < 5; i++)
+  {
+    switch (x)
+    {
+      default:
+        y++;
+    }
+  }
+  return y;
+}
+testSwitchUndefined.expected = 5;
+test(testSwitchUndefined);
+
+function testGeneratorDeepBail() {
+    function g() { yield 2; }
+    var iterables = [[1], [], [], [], g()];
+
+    var total = 0;
+    for (let i = 0; i < iterables.length; i++)
+        for each (let j in iterables[i])
+                     total += j;
+    return total;
+}
+testGeneratorDeepBail.expected = 3;
+test(testGeneratorDeepBail);
+
+function testRegexpGet() {
+    var re = /hi/;
+    var a = [];
+    for (let i = 0; i < 5; ++i)
+        a.push(re.source);
+    return a.toString();
+}
+testRegexpGet.expected = "hi,hi,hi,hi,hi";
+test(testRegexpGet);
+
+function testThrowingObjectEqUndefined()
+{
+  try
+  {
+    var obj = { toString: function() { throw 0; } };
+    for (var i = 0; i < 5; i++)
+      "" + (obj == undefined);
+    return i === 5;
+  }
+  catch (e)
+  {
+    return "" + e;
+  }
+}
+testThrowingObjectEqUndefined.expected = true;
+testThrowingObjectEqUndefined.jitstats = {
+  sideExitIntoInterpreter: 1
+};
+test(testThrowingObjectEqUndefined);
+
+function x4(v) { return "" + v + v + v + v; }
+function testConvertibleObjectEqUndefined()
+{
+  var compares =
+    [
+     false, false, false, false,
+     undefined, undefined, undefined, undefined,
+     false, false, false, false,
+     undefined, undefined, undefined, undefined,
+     false, false, false, false,
+     undefined, undefined, undefined, undefined,
+     false, false, false, false,
+     undefined, undefined, undefined, undefined,
+     false, false, false, false,
+     undefined, undefined, undefined, undefined,
+    ];
+  var count = 0;
+  var obj = { valueOf: function() { count++; return 1; } };
+  var results = compares.map(function(v) { return "unwritten"; });
+
+  for (var i = 0, sz = compares.length; i < sz; i++)
+    results[i] = compares[i] == obj;
+
+  return results.join("") + count;
+}
+testConvertibleObjectEqUndefined.expected =
+  x4(false) + x4(false) + x4(false) + x4(false) + x4(false) + x4(false) +
+  x4(false) + x4(false) + x4(false) + x4(false) + "20";
+testConvertibleObjectEqUndefined.jitstats = {
+  sideExitIntoInterpreter: 3
+};
+test(testConvertibleObjectEqUndefined);
+
+function testUndefinedPropertyAccess() {
+    var x = [1,2,3];
+    var y = {};
+    var a = { foo: 1 };
+    y.__proto__ = x;
+    var z = [x, x, x, y, y, y, y, a, a, a];
+    var s = "";
+    for (var i = 0; i < z.length; ++i)
+        s += z[i].foo;
+    return s;
+}
+testUndefinedPropertyAccess.expected = "undefinedundefinedundefinedundefinedundefinedundefinedundefined111";
+testUndefinedPropertyAccess.jitstats = {
+    traceCompleted: 3
+};
+test(testUndefinedPropertyAccess);
+
+q = "";
+function g() { q += "g"; }
+function h() { q += "h"; }
+a = [g, g, g, g, h];
+for (i=0; i<5; i++) { f = a[i];  f(); }
+
+function testRebranding() {
+    return q;
+}
+testRebranding.expected = "ggggh";
+test(testRebranding);
+delete q;
+delete g;
+delete h;
+delete a;
+delete f;
+
+function testLambdaCtor() {
+    var a = [];
+    for (var x = 0; x < RUNLOOP; ++x) {
+        var f = function(){};
+        a[a.length] = new f;
+    }
+
+    // This prints false until the upvar2 bug is fixed:
+    // print(a[HOTLOOP].__proto__ !== a[HOTLOOP-1].__proto__);
+
+    // Assert that the last f was properly constructed.
+    return a[RUNLOOP-1].__proto__ === f.prototype;
+}
+
+testLambdaCtor.expected = true;
+test(testLambdaCtor);
+
+function testNonStubGetter() {
+    let ([] = false) { (this.watch("x", /a/g)); };
+    (function () { (eval("(function(){for each (x in [1, 2, 2]);});"))(); })();
+    this.unwatch("x");
+    return "ok";
+}
+testNonStubGetter.expected = "ok";
+test(testNonStubGetter);
+
+function testString() {
+    var q;
+    for (var i = 0; i <= RUNLOOP; ++i) {
+        q = [];
+        q.push(String(void 0));
+        q.push(String(true));
+        q.push(String(5));
+        q.push(String(5.5));
+        q.push(String("5"));
+        q.push(String([5]));
+    }
+    return q.join(",");
+}
+testString.expected = "undefined,true,5,5.5,5,5";
+testString.jitstats = {
+    recorderStarted: 1,
+    sideExitIntoInterpreter: 1
+};
+test(testString);
+
+function testToStringBeforeValueOf()
+{
+  var o = {toString: function() { return "s"; }, valueOf: function() { return "v"; } };
+  var a = [];
+  for (var i = 0; i < 10; i++)
+    a.push(String(o));
+  return a.join(",");
+}
+testToStringBeforeValueOf.expected = "s,s,s,s,s,s,s,s,s,s";
+testToStringBeforeValueOf.jitstats = {
+  recorderStarted: 1,
+  sideExitIntoInterpreter: 1
+};
+test(testToStringBeforeValueOf);
+
+function testNullToString()
+{
+  var a = [];
+  for (var i = 0; i < 10; i++)
+    a.push(String(null));
+  for (i = 0; i < 10; i++) {
+    var t = typeof a[i];
+    if (t != "string")
+      a.push(t);
+  }
+  return a.join(",");
+}
+testNullToString.expected = "null,null,null,null,null,null,null,null,null,null";
+testNullToString.jitstats = {
+  recorderStarted: 2,
+  sideExitIntoInterpreter: 2,
+  recorderAborted: 0
+};
+test(testNullToString);
+
+function testAddNull()
+{
+  var rv;
+  for (var x = 0; x < HOTLOOP + 1; ++x)
+    rv = null + [,,];
+  return rv;
+}
+testAddNull.expected = "null,";
+testAddNull.jitstats = {
+  recorderStarted: 1,
+  sideExitIntoInterpreter: 1,
+  recorderAborted: 0
+};
+test(testAddNull);
+
+function testClosures()
+{
+    function MyObject(id) {
+        var thisObject = this;
+        this.id = id;
+        this.toString = str;
+
+        function str() {
+            return "" + this.id + thisObject.id;
+        }
+    }
+
+    var a = [];
+    for (var i = 0; i < 5; i++)
+        a.push(new MyObject(i));
+    return a.toString();
+}
+testClosures.expected = "00,11,22,33,44";
+test(testClosures);
+
+function testMoreClosures() {
+    var f = {}, max = 3;
+
+    var hello = function(n) {
+        function howdy() { return n * n }
+        f.test = howdy;
+    };
+
+    for (var i = 0; i <= max; i++)
+        hello(i);
+
+    return f.test();
+}
+testMoreClosures.expected = 9;
+test(testMoreClosures);
+
+function testLambdaInitedVar() {
+    var jQuery = function (a, b) {
+        return jQuery && jQuery.length;
+    }
+    return jQuery();
+}
+
+testLambdaInitedVar.expected = 2;
+test(testLambdaInitedVar);
+
+function testNestedEscapingLambdas()
+{
+    try {
+        return (function() {
+            var a = [], r = [];
+            function setTimeout(f, t) {
+                a.push(f);
+            }
+
+            function runTimeouts() {
+                for (var i = 0; i < a.length; i++)
+                    a[i]();
+            }
+
+            var $foo = "#nothiddendiv";
+            setTimeout(function(){
+                r.push($foo);
+                setTimeout(function(){
+                    r.push($foo);
+                }, 100);
+            }, 100);
+
+            runTimeouts();
+
+            return r.join("");
+        })();
+    } catch (e) {
+        return e;
+    }
+}
+testNestedEscapingLambdas.expected = "#nothiddendiv#nothiddendiv";
+test(testNestedEscapingLambdas);
+
+function testPropagatedFunArgs()
+{
+  var win = this;
+  var res = [], q = [];
+  function addEventListener(name, func, flag) {
+    q.push(func);
+  }
+
+  var pageInfo, obs;
+  addEventListener("load", handleLoad, true);
+
+  var observer = {
+    observe: function(win, topic, data) {
+      // obs.removeObserver(observer, "page-info-dialog-loaded");
+      handlePageInfo();
+    }
+  };
+
+  function handleLoad() {
+    pageInfo = { toString: function() { return "pageInfo"; } };
+    obs = { addObserver: function (obs, topic, data) { obs.observe(win, topic, data); } };
+    obs.addObserver(observer, "page-info-dialog-loaded", false);
+  }
+
+  function handlePageInfo() {
+    res.push(pageInfo);
+    function $(aId) { res.push(pageInfo); };
+    var feedTab = $("feedTab");
+  }
+
+  q[0]();
+  return res.join(',');
+}
+testPropagatedFunArgs.expected = "pageInfo,pageInfo";
+test(testPropagatedFunArgs);
+
+// Second testPropagatedFunArgs test -- this is a crash-test.
+(function () {
+  var escapee;
+
+  function testPropagatedFunArgs()
+  {
+    const magic = 42;
+
+    var win = this;
+    var res = [], q = [];
+    function addEventListener(name, func, flag) {
+      q.push(func);
+    }
+
+    var pageInfo = "pageInfo", obs;
+    addEventListener("load", handleLoad, true);
+
+    var observer = {
+      observe: function(win, topic, data) {
+        // obs.removeObserver(observer, "page-info-dialog-loaded");
+        handlePageInfo();
+      }
+    };
+
+    function handleLoad() {
+      //pageInfo = { toString: function() { return "pageInfo"; } };
+      obs = { addObserver: function (obs, topic, data) { obs.observe(win, topic, data); } };
+      obs.addObserver(observer, "page-info-dialog-loaded", false);
+    }
+
+    function handlePageInfo() {
+      res.push(pageInfo);
+      function $(aId) {
+        function notSafe() {
+          return magic;
+        }
+        notSafe();
+        res.push(pageInfo);
+      };
+      var feedTab = $("feedTab");
+    }
+
+    escapee = q[0];
+    return res.join(',');
+  }
+
+  testPropagatedFunArgs();
+
+  escapee();
+})();
+
+function testStringLengthNoTinyId()
+{
+  var x = "unset";
+  var t = new String("");
+  for (var i = 0; i < 5; i++)
+    x = t["-1"];
+
+  var r = "t['-1'] is " + x;
+  t["-1"] = "foo";
+  r += " when unset, '" + t["-1"] + "' when set";
+  return r;
+}
+testStringLengthNoTinyId.expected = "t['-1'] is undefined when unset, 'foo' when set";
+test(testStringLengthNoTinyId);
+
+function testLengthInString()
+{
+  var s = new String();
+  var res = "length" in s;
+  for (var i = 0; i < 5; i++)
+    res = res && ("length" in s);
+  res = res && s.hasOwnProperty("length");
+  for (var i = 0; i < 5; i++)
+    res = res && s.hasOwnProperty("length");
+  return res;
+}
+testLengthInString.expected = true;
+test(testLengthInString);
+
+function testSlowArrayLength()
+{
+  var counter = 0;
+  var a = [];
+  a[10000000 - 1] = 0;
+  for (var i = 0; i < a.length; i++)
+    counter++;
+  return counter;
+}
+testSlowArrayLength.expected = 10000000;
+testSlowArrayLength.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 1
+};
+test(testSlowArrayLength);
+
+function testObjectLength()
+{
+  var counter = 0;
+  var a = {};
+  a.length = 10000000;
+  for (var i = 0; i < a.length; i++)
+    counter++;
+  return counter;
+}
+testObjectLength.expected = 10000000;
+testObjectLength.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 1
+};
+test(testObjectLength);
+
+function testChangingObjectWithLength()
+{
+  var obj = { length: 10 };
+  var dense = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+  var slow = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; slow.slow = 5;
+
+  /*
+   * The elements of objs constitute a De Bruijn sequence repeated 4x to trace
+   * and run native code for every object and transition.
+   */
+  var objs = [obj, obj, obj, obj,
+              obj, obj, obj, obj,
+              dense, dense, dense, dense,
+              obj, obj, obj, obj,
+              slow, slow, slow, slow,
+              dense, dense, dense, dense,
+              dense, dense, dense, dense,
+              slow, slow, slow, slow,
+              slow, slow, slow, slow,
+              obj, obj, obj, obj];
+
+  var counter = 0;
+
+  for (var i = 0, sz = objs.length; i < sz; i++)
+  {
+    var o = objs[i];
+    for (var j = 0; j < o.length; j++)
+      counter++;
+  }
+
+  return counter;
+}
+testChangingObjectWithLength.expected = 400;
+testChangingObjectWithLength.jitstats = {
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 15 // empirically determined
+};
+test(testChangingObjectWithLength);
+
+function testNEWINIT()
+{
+    var a;
+    for (var i = 0; i < 10; ++i)
+        a = [{}];
+    return uneval(a);
+}
+testNEWINIT.expected = "[{}]";
+test(testNEWINIT);
+
+function testNEWINIT_DOUBLE()
+{
+    for (var z = 0; z < 2; ++z) { ({ 0.1: null })}
+    return "ok";
+}
+testNEWINIT_DOUBLE.expected = "ok";
+test(testNEWINIT_DOUBLE);
+
+function testIntOverflow() {
+    // int32_max - 7
+    var ival = 2147483647 - 7;
+    for (var i = 0; i < 30; i++) {
+        ival += 2;
+    }
+    return (ival < 2147483647);
+}
+testIntOverflow.expected = false;
+testIntOverflow.jitstats = {
+    recorderStarted: 2,
+    recorderAborted: 0,
+    traceCompleted: 2,
+    traceTriggered: 2,
+};
+test(testIntOverflow);
+
+function testIntUnderflow() {
+    // int32_min + 8
+    var ival = -2147483648 + 8;
+    for (var i = 0; i < 30; i++) {
+        ival -= 2;
+    }
+    return (ival > -2147483648);
+}
+testIntUnderflow.expected = false;
+testIntUnderflow.jitstats = {
+    recorderStarted: 2,
+    recorderAborted: 0,
+    traceCompleted: 2,
+    traceTriggered: 2,
+};
+test(testIntUnderflow);
+
+function testCALLELEM()
+{
+    function f() {
+        return 5;
+    }
+
+    function g() {
+        return 7;
+    }
+
+    var x = [f,f,f,f,g];
+    var y = 0;
+    for (var i = 0; i < 5; ++i)
+        y = x[i]();
+    return y;
+}
+testCALLELEM.expected = 7;
+test(testCALLELEM);
+
+function testNewString()
+{
+  var o = { toString: function() { return "string"; } };
+  var r = [];
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String(o));
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String(3));
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String(2.5));
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String("string"));
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String(null));
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String(true));
+  for (var i = 0; i < 5; i++)
+    r.push(typeof new String(undefined));
+  return r.length === 35 && r.every(function(v) { return v === "object"; });
+}
+testNewString.expected = true;
+testNewString.jitstats = {
+  recorderStarted:  7,
+  recorderAborted: 0,
+  traceCompleted: 7,
+  sideExitIntoInterpreter: 7
+};
+test(testNewString);
+
+function testWhileObjectOrNull()
+{
+  try
+  {
+    for (var i = 0; i < 3; i++)
+    {
+      var o = { p: { p: null } };
+      while (o.p)
+        o = o.p;
+    }
+    return "pass";
+  }
+  catch (e)
+  {
+    return "threw exception: " + e;
+  }
+}
+testWhileObjectOrNull.expected = "pass";
+test(testWhileObjectOrNull);
+
+function testDenseArrayProp()
+{
+    [].__proto__.x = 1;
+    ({}).__proto__.x = 2;
+    var a = [[],[],[],({}).__proto__];
+    for (var i = 0; i < a.length; ++i)
+        uneval(a[i].x);
+    delete [].__proto__.x;
+    delete ({}).__proto__.x;
+    return "ok";
+}
+testDenseArrayProp.expected = "ok";
+test(testDenseArrayProp);
+
+function testNewWithNonNativeProto()
+{
+  function f() { }
+  var a = f.prototype = [];
+  for (var i = 0; i < 5; i++)
+    var o = new f();
+  return Object.getPrototypeOf(o) === a && o.splice === Array.prototype.splice;
+}
+testNewWithNonNativeProto.expected = true;
+testNewWithNonNativeProto.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  sideExitIntoInterpreter: 1
+};
+test(testNewWithNonNativeProto);
+
+function testLengthOnNonNativeProto()
+{
+  var o = {};
+  o.__proto__ = [3];
+  for (var j = 0; j < 5; j++)
+    o[0];
+
+  var o2 = {};
+  o2.__proto__ = [];
+  for (var j = 0; j < 5; j++)
+    o2.length;
+
+  function foo() { }
+  foo.__proto__ = [];
+  for (var j = 0; j < 5; j++)
+    foo.length;
+
+  return "no assertion";
+}
+testLengthOnNonNativeProto.expected = "no assertion";
+test(testLengthOnNonNativeProto);
+
+function testDeepPropertyShadowing()
+{
+    function h(node) {
+        var x = 0;
+        while (node) {
+            x++;
+            node = node.parent;
+        }
+        return x;
+    }
+    var tree = {__proto__: {__proto__: {parent: null}}};
+    h(tree);
+    h(tree);
+    tree.parent = {};
+    assertEq(h(tree), 2);
+}
+test(testDeepPropertyShadowing);
+
+// Complicated whitebox test for bug 487845.
+function testGlobalShapeChangeAfterDeepBail() {
+    function f(name) {
+        this[name] = 1;  // may change global shape
+        for (var i = 0; i < 4; i++)
+            ; // MonitorLoopEdge eventually triggers assertion
+    }
+
+    // When i==3, deep-bail, then change global shape enough times to exhaust
+    // the array of GlobalStates.
+    var arr = [[], [], [], ["bug0", "bug1", "bug2", "bug3", "bug4"]];
+    for (var i = 0; i < arr.length; i++)
+        arr[i].forEach(f);
+}
+test(testGlobalShapeChangeAfterDeepBail);
+for (let i = 0; i < 5; i++)
+    delete this["bug" + i];
+
+function testFunctionIdentityChange()
+{
+  function a() {}
+  function b() {}
+
+  var o = { a: a, b: b };
+
+  for (var prop in o)
+  {
+    for (var i = 0; i < 1000; i++)
+      o[prop]();
+  }
+
+  return true;
+}
+testFunctionIdentityChange.expected = true;
+testFunctionIdentityChange.jitstats = {
+  recorderStarted: 2,
+  traceCompleted: 2,
+  sideExitIntoInterpreter: 3
+};
+test(testFunctionIdentityChange);
+
+function testStringObjectLength() {
+    var x = new String("foo"), y = 0;
+    for (var i = 0; i < 10; ++i)
+        y = x.length;
+    return y;
+}
+testStringObjectLength.expected = 3;
+test(testStringObjectLength);
+
+var _quit;
+function testNestedDeepBail()
+{
+    _quit = false;
+    function loop() {
+        for (var i = 0; i < 4; i++)
+            ;
+    }
+    loop();
+
+    function f() {
+        loop();
+        _quit = true;
+    }
+    var stk = [[1], [], [], [], []];
+    while (!_quit)
+        stk.pop().forEach(f);
+}
+test(testNestedDeepBail);
+delete _quit;
+
+function testSlowNativeCtor() {
+    for (var i = 0; i < 4; i++)
+        new Date().valueOf();
+}
+test(testSlowNativeCtor);
+
+function testSlowNativeBail() {
+    var a = ['0', '1', '2', '3', '+'];
+    try {
+        for (var i = 0; i < a.length; i++)
+            new RegExp(a[i]);
+    } catch (exc) {
+        assertEq(""+exc.stack.match(/^RegExp/), "RegExp");
+    }
+}
+test(testSlowNativeBail);
+
+/* Test the proper operation of the left shift operator. This is especially
+ * important on ARM as an explicit mask is required at the native instruction
+ * level. */
+function testShiftLeft()
+{
+    var r = [];
+    var i = 0;
+    var j = 0;
+
+    var shifts = [0,1,7,8,15,16,23,24,31];
+
+    /* Samples from the simple shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << shifts[i];
+
+    /* Samples outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << (shifts[i] + 32);
+
+    /* Samples far outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << (shifts[i] + 224);
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << (shifts[i] + 256);
+
+    return r.join(",");
+}
+testShiftLeft.expected =
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648,"+
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648,"+
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648,"+
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648";
+test(testShiftLeft);
+
+/* Test the proper operation of the logical right shift operator. This is
+ * especially important on ARM as an explicit mask is required at the native
+ * instruction level. */
+function testShiftRightLogical()
+{
+    var r = [];
+    var i = 0;
+    var j = 0;
+
+    var shifts = [0,1,7,8,15,16,23,24,31];
+
+    /* Samples from the simple shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> shifts[i];
+
+    /* Samples outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> (shifts[i] + 32);
+
+    /* Samples far outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> (shifts[i] + 224);
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> (shifts[i] + 256);
+
+    return r.join(",");
+}
+/* Note: Arguments to the ">>>" operator are converted to unsigned 32-bit
+ * integers during evaluation. As a result, -2147483648 >>> 0 evaluates to the
+ * unsigned interpretation of the same value, which is 2147483648. */
+testShiftRightLogical.expected =
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1,"+
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1,"+
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1,"+
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1";
+test(testShiftRightLogical);
+
+/* Test the proper operation of the arithmetic right shift operator. This is
+ * especially important on ARM as an explicit mask is required at the native
+ * instruction level. */
+function testShiftRightArithmetic()
+{
+    var r = [];
+    var i = 0;
+    var j = 0;
+
+    var shifts = [0,1,7,8,15,16,23,24,31];
+
+    /* Samples from the simple shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> shifts[i];
+
+    /* Samples outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> (shifts[i] + 32);
+
+    /* Samples far outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> (shifts[i] + 224);
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> (shifts[i] + 256);
+
+    return r.join(",");
+}
+testShiftRightArithmetic.expected =
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1,"+
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1,"+
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1,"+
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1";
+test(testShiftRightArithmetic);
+
+function testStringConstructorWithExtraArg() {
+    for (let i = 0; i < 5; ++i)
+        new String(new String(), 2);
+    return "ok";
+}
+testStringConstructorWithExtraArg.expected = "ok";
+test(testStringConstructorWithExtraArg);
+
+function testConstructorBail() {
+    for (let i = 0; i < 5; ++i) new Number(/x/);
+}
+test(testConstructorBail);
+
+function testNewArrayCount()
+{
+  var a = [];
+  for (var i = 0; i < 5; i++)
+    a = [0];
+  assertEq(a.__count__, 1);
+  for (var i = 0; i < 5; i++)
+    a = [0, , 2];
+  assertEq(a.__count__, 2);
+}
+test(testNewArrayCount);
+
+function testNewArrayCount2() {
+    var x = 0;
+    for (var i = 0; i < 10; ++i)
+        x = new Array(1,2,3).__count__;
+    return x;
+}
+testNewArrayCount2.expected = 3;
+test(testNewArrayCount2);
+
+/*****************************************************************************
+ *                                                                           *
+ *  _____ _   _  _____ ______ _____ _______                                  *
+ * |_   _| \ | |/ ____|  ____|  __ \__   __|                                 *
+ *   | | |  \| | (___ | |__  | |__) | | |                                    *
+ *   | | | . ` |\___ \|  __| |  _  /  | |                                    *
+ *  _| |_| |\  |____) | |____| | \ \  | |                                    *
+ * |_____|_| \_|_____/|______|_|  \_\ |_|                                    *
+ *                                                                           *
+ *                                                                           *
+ *  _______ ______  _____ _______ _____                                      *
+ * |__   __|  ____|/ ____|__   __/ ____|                                     *
+ *    | |  | |__  | (___    | | | (___                                       *
+ *    | |  |  __|  \___ \   | |  \___ \                                      *
+ *    | |  | |____ ____) |  | |  ____) |                                     *
+ *    |_|  |______|_____/   |_| |_____/                                      *
+ *                                                                           *
+ *                                                                           *
+ *  ____  ______ ______ ____  _____  ______    _    _ ______ _____  ______   *
+ * |  _ \|  ____|  ____/ __ \|  __ \|  ____|  | |  | |  ____|  __ \|  ____|  *
+ * | |_) | |__  | |__ | |  | | |__) | |__     | |__| | |__  | |__) | |__     *
+ * |  _ <|  __| |  __|| |  | |  _  /|  __|    |  __  |  __| |  _  /|  __|    *
+ * | |_) | |____| |   | |__| | | \ \| |____   | |  | | |____| | \ \| |____   *
+ * |____/|______|_|    \____/|_|  \_\______|  |_|  |_|______|_|  \_\______|  *
+ *                                                                           *
+ *****************************************************************************/
+
+// math-trace-tests.js is a separate file here.
+
+// MANDELBROT STUFF deleted
+
+/*****************************************************************************
+ *  _   _  ____     _   __  ____  _____  ______                              *
+ * | \ | |/ __ \   |  \/  |/ __ \|  __ \|  ____|                             *
+ * |  \| | |  | |  | \  / | |  | | |__) | |__                                *
+ * | . ` | |  | |  | |\/| | |  | |  _  /|  __|                               *
+ * | |\  | |__| |  | |  | | |__| | | \ \| |____                              *
+ * |_| \_|\____/   |_|  |_|\____/|_|  \_\______|                             *
+ *                                                                           *
+ *  _______ ______  _____ _______ _____                                      *
+ * |__   __|  ____|/ ____|__   __/ ____|                                     *
+ *    | |  | |__  | (___    | | | (___                                       *
+ *    | |  |  __|  \___ \   | |  \___ \                                      *
+ *    | |  | |____ ____) |  | |  ____) |                                     *
+ *    |_|  |______|_____/   |_| |_____/                                      *
+ *                                                                           *
+ *           ______ _______ ______ _____     _    _ ______ _____  ______ _   *
+ *     /\   |  ____|__   __|  ____|  __ \   | |  | |  ____|  __ \|  ____| |  *
+ *    /  \  | |__     | |  | |__  | |__) |  | |__| | |__  | |__) | |__  | |  *
+ *   / /\ \ |  __|    | |  |  __| |  _  /   |  __  |  __| |  _  /|  __| | |  *
+ *  / ____ \| |       | |  | |____| | \ \   | |  | | |____| | \ \| |____|_|  *
+ * /_/    \_\_|       |_|  |______|_|  \_\  |_|  |_|______|_|  \_\______(_)  *
+ *                                                                           *
+ *****************************************************************************/
+
+/* NOTE: Keep this test last, since it screws up all for...in loops after it. */
+function testGlobalProtoAccess() {
+  return "ok";
+}
+this.__proto__.a = 3; for (var j = 0; j < 4; ++j) { [a]; }
+testGlobalProtoAccess.expected = "ok";
+test(testGlobalProtoAccess);
+
+jit(false);
+
 /* Keep these at the end so that we can see the summary after the trace-debug spew. */
-print("\npassed:", passes.length && passes.join(","));
-print("\nFAILED:", fails.length && fails.join(","));
-
+if (gReportSummary) {
+  print("\npassed:", passes.length && passes.join(","));
+  print("\nFAILED:", fails.length && fails.join(","));
+}