Bug 838148 - Add 63 missing jit-tests for various bugs. rs=terrence

js/src/jit-test/tests/auto-regress/bug499169.js

@@ -0,0 +1,179 @@
+// Binary: cache/js-dbg-32-30b481fd82f5-linux
+// Flags: -j
+//
+var Native = function(k) {
+    var f = k.initialize;
+    var d = f;
+    var j = function(n, l, o, m) {
+        n.prototype[l] = o;
+    };
+    d.alias = function(n, l, o) {
+        n = this.prototype[n]
+        return j(this, l, n, o);
+    };
+    d.implement = function(m, l, o) {
+        for (var n in m) {
+            j(this, n, m[n], l);
+        }
+    }
+    return d;
+};
+(function() {
+    var a = {
+        Array: Array,
+        Function: Function,
+    };
+    for (var h in a) {
+        new Native({
+            initialize: a[h],
+        });
+    }
+} ());
+Array.alias("forEach", "each");
+function $merge() {
+    var a = Array.slice(arguments);
+    a.unshift({});
+    return $mixin.apply(null, a);
+}
+function $mixin(e) {
+    for (var d = 1, a = arguments.length; d < a; d++) {
+        var b = arguments[d];
+        for (var c in b) {
+            var g = b[c],
+            f = e[c];
+            e[c] = f && $type(g) == "object" && $type(f) == "object" ? $mixin(f, g) : $unlink(g);
+        }
+    }
+}
+function $type(a) {
+    if (a == undefined) {
+        return false;
+    }
+    if (a.$family) {
+    }
+    return typeof a;
+}
+function $unlink(c) {
+    if ($type(c) == "object") {
+        b = {};
+    }
+    return b;
+}
+var Window = new Native({
+    initialize: function(a) {},
+});
+Array.implement({
+    extend: function(c) {
+        return this;
+    }
+});
+Function.implement({
+    extend: function(a) {
+        for (var b in a) {
+            this[b] = a[b];
+        }
+        return this;
+    },
+    run: function(a, b) {
+        return this.apply(b, a);
+    }
+});
+function Class(b) {
+    var a = function() {
+        Object.reset(this);
+        var c = this.initialize ? this.initialize.apply(this, arguments) : this;
+    }.extend(this);
+    a.implement(b);
+    return a;
+}
+Object.reset = function(a, c) {
+    if (c == null) {
+        for (var e in a) {
+            Object.reset(a, e);
+        }
+    }
+    switch ($type(a[c])) {
+    case "object":
+        var d = function() {};
+        d.prototype = a[c];
+        var b = new d;
+        a[c] = Object.reset(b);
+    }
+    return a;
+};
+(new Native({initialize: Class})).extend({});
+    function wrap(a, b, c) {
+        return function() {
+            var d = c.apply(this, arguments);
+        }.extend({});
+    }
+Class.implement({
+    implement: function(a, d) {
+        if ($type(a) == "object") {
+            for (var e in a) {
+                this.implement(e, a[e]);
+            }
+        }
+        var f = Class.Mutators[a];
+        if (f) {
+            d = f.call(this, d);
+        }
+        var c = this.prototype;
+        switch ($type(d)) {
+        case "function":
+            c[a] = wrap(this, a, d);
+            break;
+        case "object":
+            var b = c[a];
+            if ($type(b) == "object") {
+                $mixin(b, d);
+            } else {
+                c[a] = $unlink(d);
+            }
+        }
+    }
+});
+Class.Mutators = {
+    Extends: function(a) {
+        this.prototype = new a;
+    },
+    Implements: function(a) {
+        a.each(function(b) {
+            b = new b;
+            this.implement(b);
+        },
+        this);
+    }
+};
+var Events = new Class({});
+var Options = new Class({
+    setOptions: function() {
+        this.options = $merge.run([this.options].extend(arguments));
+    }
+});
+var Autocompleter = {};
+Autocompleter.Base = new Class({
+    Implements: [Options, Events],
+    options: {},
+});
+Autocompleter.Ajax = {};
+Autocompleter.Ajax.Base = new Class({
+    Extends: Autocompleter.Base,
+    options: {
+        postVar: "value",
+        onRequest: function(){},
+    }
+});
+Autocompleter.Ajax.Json = new Class({
+    Extends: Autocompleter.Ajax.Base,
+});
+Autocompleter.JsonP = new Class({
+    Extends: Autocompleter.Ajax.Json,
+    options: {
+        minLength: 1
+    },
+    initialize: function(el, url, options) {
+        this.setOptions({});
+    }
+});
+new Autocompleter.JsonP();

js/src/jit-test/tests/auto-regress/bug505305.js

@@ -0,0 +1,5 @@
+// Binary: cache/js-dbg-32-aa85b2f55960-linux
+// Flags:
+//
+var str = 'afoo$40bar'.substr(1);
+print(str.replace(str, str));

js/src/jit-test/tests/auto-regress/bug617485.js

@@ -0,0 +1,6 @@
+// |jit-test| error:SyntaxError
+
+// Binary: cache/js-dbg-64-4c1fbfcf1d0d-linux
+// Flags:
+//
+Iterator(evalcx('#2=*'))

js/src/jit-test/tests/auto-regress/bug677386.js

@@ -0,0 +1,25 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-82545b1e4129-linux
+// Flags:
+//
+
+var g = newGlobal('new-compartment');
+g.eval("var line0 = Error().lineNumber;\n" +
+       "function f() {\n" +     // line0 + 1
+       "    return 2;\n" +      // line0 + 2
+       "}\n");
+var N = 4;
+for (var i = 0; i < N; i++) {
+    var dbg = Debugger(g);
+    dbg.onDebuggerStatement = function (frame) {
+        var handler = {hit: function () { hits++; }};
+        var s = frame.eval("f").return.script;
+        var offs = s.getLineOffsets(g.line0 + 2);
+        for (var j = 0; j < offs.length; j++)
+            s.setBreakpoint(offs[j], handler);
+    };
+    g.eval('debugger;');
+}
+gc(/c$...$/);
+assertEq(g.f(), 2);

js/src/jit-test/tests/auto-regress/bug677587.js

@@ -0,0 +1,11 @@
+// Binary: cache/js-dbg-64-f189dd6316eb-linux
+// Flags:
+//
+
+var g = newGlobal('new-compartment');
+g.eval("var a = {};");
+var dbg = new Debugger;
+var gw = dbg.addDebuggee(g);
+var desc = gw.getOwnPropertyDescriptor("a");
+gw.defineProperty("b", desc);
+Debugger(g.a, g.b);

js/src/jit-test/tests/auto-regress/bug677977.js

@@ -0,0 +1,26 @@
+// Binary: cache/js-dbg-64-48e43edc8834-linux
+// Flags:
+//
+
+var g = newGlobal('new-compartment');
+var dbg = Debugger(g);
+dbg.onDebuggerStatement = function (frame) {
+    var s = frame.eval("f").return.script;
+};
+function test(s) {
+    g.eval("line0 = Error().lineNumber;\n" +
+           "debugger;\n" +          // line0 + 1
+           "function f(i) {\n" +    // line0 + 2
+           "}\n");
+}
+test("i = 128;\n" +  "}\n");
+var hits = 0;
+dbg.onNewScript = function (s) {
+    hits++;
+};
+assertEq(g.eval("eval('2 + 3')"), 5);
+this.gczeal(hits, 2);
+var fn = g.Function("a", "return 5 + a;");
+var g2 = newGlobal('new-compartment');
+dbg.addDebuggee(g2, dbg);
+g2.clone(fn);

js/src/jit-test/tests/auto-regress/bug678086.js

@@ -0,0 +1,17 @@
+// |jit-test| error:Error
+
+// Binary: cache/js-dbg-64-48e43edc8834-linux
+// Flags:
+//
+
+function f() {
+    frame = dbg.getNewestFrame();
+}
+var g = newGlobal('new-compartment');
+g.f = function (a, b) { return a + "/" + this . f( ) ; };
+var dbg = Debugger(g);
+dbg.onDebuggerStatement = function (frame) {
+    var f = frame.eval("f").return;
+    assertEq(f.call(null, "a", "b").return, "a/b");
+};
+g.eval("debugger;");

js/src/jit-test/tests/auto-regress/bug678529.js

@@ -0,0 +1,11 @@
+// |jit-test| error:Error
+
+// Binary: cache/js-dbg-32-48e43edc8834-linux
+// Flags: -j -m -a
+//
+
+var g = newGlobal('new-compartment');
+var dbg = Debugger(g);
+dbg.onDebuggerStatement = function (stack) { return {return: 1234}; };
+g.eval("function f() { debugger; return 'bad'; }");
+assertEq(new g.f(), 1234);

js/src/jit-test/tests/auto-regress/bug690933.js

@@ -0,0 +1,14 @@
+// |jit-test| slow;
+
+// Binary: cache/js-dbg-32-1463dc6308a8-linux
+// Flags:
+//
+
+var fe="vv";
+for (i=0; i<24; i++)
+  fe += fe;
+var fu=new Function(
+  fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe,
+  fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe, fe,
+  "done"
+);

js/src/jit-test/tests/auto-regress/bug691593.js

@@ -0,0 +1,18 @@
+// Binary: cache/js-dbg-64-acf3c1fb7c94-linux
+// Flags:
+//
+
+genexp = "x * x for (x in [])";
+genexpParened = "(" + genexp + ")";
+needParens(2, "if (1, xx) { }");
+function needParens(section, pat, exp) {
+  ft = pat.replace(/xx/, genexpParened);
+  try {
+    f = new Function(ft);
+  } catch(e) {  }
+  overParenTest(section, f, exp);
+}
+function overParenTest(section, f, exp) {
+  var uf = "" + f;
+  if (uf.indexOf(genexpParened) != -1) {  }
+}

js/src/jit-test/tests/auto-regress/bug691595.js

@@ -0,0 +1,20 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-acf3c1fb7c94-linux
+// Flags: --ion-eager
+//
+
+function k(f_arg) {
+  for (var i = 0; i < 10; ++i) {
+    f_arg(  ) ;
+  }
+}
+function t() {
+  k(function (i) { actual ^ this | this; });
+}
+var ans = 0;
+for (var j = 0; j < 10; ++j) {
+  for (var i = 0; i < 10; ++i) {
+    ans += t();
+  }
+}

js/src/jit-test/tests/auto-regress/bug698148.js

@@ -0,0 +1,16 @@
+// Binary: cache/js-dbg-64-b01eb1ba58ce-linux
+// Flags:
+//
+
+expect = 'Test skipped.';
+function addPointImagedata(pointArray, n, col, row) {
+    pointArray[expect + 2] = 2;
+}
+function createMandelSet() {
+    points = new Array;
+    for (var idx = 0; idx < 1440000 ; ++idx) {
+    	points[idx] = 0
+    }
+    addPointImagedata(points, ({}, {}), 0,0)
+}
+createMandelSet();

js/src/jit-test/tests/auto-regress/bug698150.js

@@ -0,0 +1,12 @@
+// Binary: cache/js-dbg-64-b01eb1ba58ce-linux
+// Flags: -m -n
+//
+
+gczeal(2);
+var g1 = newGlobal('same-compartment');
+var proxyStr = "Proxy.create(                                    "+
+"  { getOwnPropertyDescriptor: function() assertEq(true,false),  "+
+"    fix: function() assertEq(true,false), },                    "+
+"  Object.prototype                                              "+
+");                                                              ";
+var proxy1 = g1.eval(proxyStr);

js/src/jit-test/tests/auto-regress/bug700295.js

@@ -0,0 +1,18 @@
+// Binary: cache/js-dbg-64-1210706b4576-linux
+// Flags:
+//
+
+this.__proto__ = null;
+Object.prototype.__proto__ = this;
+function exploreProperties(obj) {
+  var props = [];
+  for (var o = obj; o; o = Object.getPrototypeOf(o)) {
+    props = props.concat(Object.getOwnPropertyNames(o));
+  }
+  for (var i = 0; i < props.length; ++i) {
+    var p = props[i];
+    var v = obj[p];
+  }
+}
+var c = [{}];
+exploreProperties(c);

js/src/jit-test/tests/auto-regress/bug701332.js

@@ -0,0 +1,15 @@
+// |jit-test| error:InternalError; slow;
+
+// Binary: cache/js-dbg-64-c60535115ea1-linux
+// Flags:
+//
+
+gczeal(2);
+test();
+function test() {
+  function t(o, proplist) {
+    var props=proplist.split(/\s+/g);
+  };
+  t({ bar: 123, baz: 123, quux: 123 }, 'bar baz quux');
+  ( test(), this )(( "7.4.2-6-n" ) , actual, summary + ' : nonjit');
+}

js/src/jit-test/tests/auto-regress/bug704136.js

@@ -0,0 +1,8 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-a335853be219-linux
+// Flags:
+//
+
+gczeal(4);
+jsTestDriverEnd();

js/src/jit-test/tests/auto-regress/bug719686.js

@@ -0,0 +1,32 @@
+// |jit-test| slow;
+
+// Binary: cache/js-dbg-32-e5e66f40c35b-linux
+// Flags:
+//
+
+gczeal(2);
+function subset(list, size) {
+  if (size == 0 || !list.length)
+    return [list.slice(0, 0)];
+  var result = [];
+  for (var i = 0, n = list.length; i < n; i++) {
+    var pick = list.slice(i, i+1);
+    var rest = list.slice(0, i).concat(list.slice(i+1));
+    for each (var x in subset(rest, size-1))
+      result.push(pick.concat(x));
+  }
+  return result;
+}
+var bops = [
+  ["=", "|=", "^=", "&=", "<<=", ">>=", ">>>=", "+=", "-=", "*=", "/=", "%="],
+  ];
+var aops = [];
+for (var i = 0; i < bops.length; i++) {
+  for (var j = 0; j < bops[i].length; j++) {
+    var k = bops[i][j];
+    aops.push(k);
+}
+for (i = 2; i < 5; i++) {
+  var sets = subset(aops, i);
+  }
+}

js/src/jit-test/tests/auto-regress/bug724875.js

@@ -0,0 +1,15 @@
+// Binary: cache/js-dbg-64-c34398f961e7-linux
+// Flags: --ion-eager
+//
+
+var lfcode = new Array();
+lfcode.push("gczeal(4);");
+lfcode.push("");
+while (true) {
+	var file = lfcode.shift();
+	if (file == undefined) { break; }
+        loadFile(file);
+}
+function loadFile(lfVarx) {
+	eval(lfVarx);
+}

js/src/jit-test/tests/auto-regress/bug729571.js

@@ -0,0 +1,42 @@
+// Binary: cache/js-dbg-64-ca97bbcd6b90-linux
+// Flags: --ion-eager
+//
+
+gczeal(4);
+function TestCase(n, d, e, a) {}
+TestCase.prototype.dump = function () {};
+TestCase.prototype.testFailed = (function TestCase_testFailed() {
+	});
+  try  {
+    try    {    }    catch(ex1)    {    }
+  }  catch(ex)  {  }
+  options.initvalues  = {};
+  var optionNames = options().split(',');
+  var optionsframe = {};
+  try  {
+    optionsClear();
+  }  catch(ex)  {  }
+var lfcode = new Array();
+lfcode.push("\
+  try {  } catch (exception) {  }\
+    try {    } catch (exception) {    }\
+    try {    } catch (exception) {    }\
+    try {    } catch (actual) {    }\
+        var props = {};\
+  function test(which) {\
+    var g = newGlobal(\"new-compartment\");\
+    function addDebugger(g, i) {\
+        var dbg = Debugger(g);\
+        dbg.onDebuggerStatement = function (frame) { };\
+    }\
+    for (var i = 0; i < 3; i++) {\
+        addDebugger(g, i);\
+    }\
+    g.eval(\"debugger;\");\
+}\
+for (var j = 0; j < 3; j++) test(j);\
+");
+while (true) {
+	var file = lfcode.shift(); if (file == undefined) { break; }
+	try { evaluate(file); } catch (lfVare) { }
+}

js/src/jit-test/tests/auto-regress/bug729797.js

@@ -0,0 +1,15 @@
+// |jit-test| error:InternalError
+
+// Binary: cache/js-dbg-64-5a04fd69aa09-linux
+// Flags: --ion-eager
+//
+
+var patterns = new Array();
+patterns[0] = '';
+test();
+function test() {
+  for (i in patterns) {
+    s = patterns[i];
+    status =(test)(s);
+  }
+}

js/src/jit-test/tests/auto-regress/bug729886.js

@@ -0,0 +1,12 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-opt-64-5a04fd69aa09-linux
+// Flags: --ion-eager
+//
+
+function deep1(x) {
+    if (0) {  }
+    else i : dumpStack();
+}
+for (var i = 0; 1; ++i)
+    deep1(i);

js/src/jit-test/tests/auto-regress/bug732852.js

@@ -0,0 +1,10 @@
+// |jit-test| error:SyntaxError
+
+// Binary: cache/js-dbg-64-1fd6c40d3852-linux
+// Flags: --ion-eager
+//
+
+var ary = ["\u001Cfoo", "\u001Dfoo", "\u001Efoo", "\u001Ffoo"];
+for (var i in ary) {
+  ary[Number(i)].search("var MYVAR='077';++MYVAR")
+}

js/src/jit-test/tests/auto-regress/bug732855.js

@@ -0,0 +1,69 @@
+// Binary: cache/js-dbg-64-1fd6c40d3852-linux
+// Flags: --ion-eager
+//
+function TestCase(n, d, e, a) {}
+var msPerDay =   86400000;
+var msPerHour =   3600000;
+var now = new Date();
+var TIME_NOW = now.valueOf();
+function DaysInYear( y ) {
+  if ( y % 4 != 0 ) {
+    return 365;
+  }
+    return 366;
+}
+function TimeInYear( y ) {
+  return ( DaysInYear(y) * msPerDay );
+}
+function TimeFromYear( y ) {
+  return ( msPerDay * DayFromYear(y) );
+}
+function DayFromYear( y ) {
+  return ( 365*(y-1970) +
+           Math.floor((y-1601)/400) );
+}
+function InLeapYear( t ) {
+  if ( DaysInYear(YearFromTime(t)) == 365 ) {
+    return 0;
+  }
+  if ( DaysInYear(YearFromTime(t)) == 366 ) {
+  }
+}
+function YearFromTime( t ) {
+  var sign = ( t < 0 ) ? -1 : 1;
+  var year = ( sign < 0 ) ? 1969 : 1970;
+  for ( var timeToTimeZero = t; ;  ) {
+    timeToTimeZero -= sign * TimeInYear(year)
+      if ( sign < 0 ) {
+      } else {
+        if ( sign * timeToTimeZero < 0 ) {
+          break;
+        } else {
+          year += sign;
+        }
+      }
+  }
+  return ( year );
+}
+function WeekDay( t ) {}
+function LocalTZA() {}
+function LocalTime( t ) {
+  var dst_start = GetDSTStart(t);
+}
+function GetFirstSundayInMonth( t, m ) {
+  var leap = InLeapYear(t);
+}
+function GetDSTStart( t ) {
+  return (GetFirstSundayInMonth(t, 2) + 7*msPerDay + 2*msPerHour - LocalTZA());
+}
+var SECTION = "15.9.5.12";
+addTestCase( TIME_NOW );
+function addTestCase( t ) {
+  var start = TimeFromYear(YearFromTime(t));
+  var stop  = TimeFromYear(YearFromTime(t) + 1);
+  for (var d = start; d < stop; d += msPerDay) {
+    new TestCase( SECTION,
+                  WeekDay((LocalTime(d))),
+                  (__lookupGetter__) );
+  }
+}

js/src/jit-test/tests/auto-regress/bug732856.js

@@ -0,0 +1,19 @@
+// Binary: cache/js-dbg-64-1fd6c40d3852-linux
+// Flags: --ion-eager
+//
+
+var cnName = 'name';
+var cnNameGetter = function() {this.nameGETS++; return this._name;};
+obj = (new (function  (  )  {  }  )         );
+obj.__defineGetter__(cnName, cnNameGetter);
+function lameFunc(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (obj.name) + (y >> 16) + (lsw >> 16);
+}
+function runSomeTimes(func, iters) {
+    for (var i = 0; i < iters; ++i) {
+        result = func(42, 42);
+    }
+}
+for (var i = 0; i < 11000; ++i)
+    runSomeTimes(lameFunc, 1);

js/src/jit-test/tests/auto-regress/bug732857.js

@@ -0,0 +1,30 @@
+// Binary: cache/js-dbg-32-1fd6c40d3852-linux
+// Flags: --ion-eager
+//
+
+function TestCase(n, d, e, a) {};
+  this.__proto__ = [];
+var msPerDay =   86400000;
+var TIME_1900  = -2208988800000;
+function TimeFromYear( y ) {
+  return ( msPerDay * DayFromYear(y) );
+}
+function DayFromYear( y ) {
+  return ( 365*(y-1970) +
+           Math.floor((y-1601)/400) );
+}
+function YearFromTime( t ) {
+  var sign = ( t < 0 ) ? -1 : 1;
+  var year = ( sign < 0 ) ? 1969 : 1970;
+  return ( year );
+}
+var SECTION = "15.9.5.10";
+addTestCase( TIME_1900 );
+function addTestCase( t ) {
+  var start = TimeFromYear(YearFromTime(t));
+  var stop  = TimeFromYear(YearFromTime(t) + 1);
+  for (var d = start; d < stop; d += msPerDay) {
+    new TestCase( SECTION,
+                  (new Date( SECTION   ? "Failed" : prototype +=  "'abc'.search(new RegExp('^'))") ).getDate() );
+  }
+}

js/src/jit-test/tests/auto-regress/bug732861.js

@@ -0,0 +1,12 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-1fd6c40d3852-linux
+// Flags: --ion-eager
+//
+
+j = 0;
+out1:
+for ((exception) = 0; ; j++)
+    if (j == 50)
+        break out1;
+while (dbgeval("[]").proto ? g : 50) {}

js/src/jit-test/tests/auto-regress/bug737300.js

@@ -0,0 +1,21 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-b5b6e6aebb36-linux
+// Flags: --ion-eager
+//
+
+function loopy(p0)
+{
+ var r3 = p0;
+ var r4 = p0;
+ var r6 = p0;
+ var r7 = p0;
+ while (r2) {
+  while (r2) {
+   r5 = r6 & r1;
+   r3 = r4 & r3;
+   r2 = r7;
+  }
+ }
+}
+loopy(0);

js/src/jit-test/tests/auto-regress/bug737737.js

@@ -0,0 +1,36 @@
+// Binary: cache/js-dbg-32-e96d5b1f47b8-linux
+// Flags: --ion-eager
+//
+function b(z) {
+  switch (z) {
+  default:
+    primarySandbox = newGlobal("new-compartment")
+  }
+  return function(f, code) {
+    try {
+      evalcx(code, primarySandbox)
+    } catch (e) {}
+  }
+}
+function a(code) {
+  gc();
+  f = Function(code)
+  c(f, code)
+}
+c = b()
+a("\
+  f2 = (function() {\
+    a0 + o2.m;\
+    a2.shift()\
+  });\
+  a2 = new Array;\
+  Object.defineProperty(a2, 0, {\
+    get: f2\
+  });\
+  o2 = {};\
+  a0 = [];\
+  a2.shift();\
+  var x;\
+")
+a("a0 = x")
+a("a2.shift()")

js/src/jit-test/tests/auto-regress/bug739402.js

@@ -0,0 +1,142 @@
+// |jit-test| slow;
+
+// Binary: cache/js-dbg-32-be41973873db-linux
+// Flags: --ion-eager
+//
+function MersenneTwister19937() {
+  N = 624;
+  var M = 397;
+  MATRIX_A = 567483615;
+  UPPER_MASK = 2147483648;
+  var LOWER_MASK = 767;
+  mt = Array();
+  function unsigned32(n1) {
+    return n1 < 0 ? (n1 ^ UPPER_MASK) + UPPER_MASK : n1;
+  }
+  function addition32(n1, n2) {
+    return unsigned32(n1 + n2 & 4294967295);
+  }
+  function multiplication32(n1, n2) {
+    sum = 0;
+    for (i = 0; i < 32; ++i) {
+      if (n1 >> i & 1) {
+        sum = addition32(sum, unsigned32(n2 << i));
+      }
+    }
+    return sum;
+  }
+  this.init_genrand = function() {
+    for (mti = 1; mti < N; mti++) {
+      mt[mti] = addition32(multiplication32(181433253, unsigned32(mt[mti - 1] ^ mt[mti - 1] >>> 30)), mti);
+    }
+  };
+  this.genrand_int32 = function() {
+    mag01 = Array(0, MATRIX_A);
+    if (mti > N) {
+      for (kk = 0; kk < N - M; kk++) {
+        y = unsigned32(mt[kk] & UPPER_MASK | mt[kk + 1] & LOWER_MASK);
+      }
+      for (; kk < N; kk++) {
+        mt[kk] = unsigned32(mt[kk + (M - N)] ^ y >>> 1 ^ mag01[y & 1]);
+      }
+      mti = 0;
+    }
+    y = mt[mti++];
+    return y;
+  };
+}
+(function() {
+  var fuzzMT = new MersenneTwister19937;
+  fuzzSeed = 4;
+  fuzzMT.init_genrand(fuzzSeed);
+  rnd = function(n) {
+    var x = fuzzMT.genrand_int32() * 2.2e-10;
+    return Math.floor(x * n);
+  };
+}());
+
+function rndElt(a) {
+  return a[rnd(a.length)];
+}
+varBinderFor = ["", "t", ""];
+function forLoopHead(d, b, v, reps) {
+  var sInit = rndElt(varBinderFor) + v + "=0";
+  var sCond = v + "<" + reps;
+  sNext = "++" + v;
+  return "for(" + sInit + ";" + sCond + ";" + sNext + ")";
+}
+function makeBranchUnstableLoop(d, b) {
+  var reps = rnd(rnd(9));
+  v = uniqueVarName();
+  var mod = rnd();
+  target = rnd(mod);
+  return "" + forLoopHead(d, b, v, reps) + "{" + "if(" + v + "%" + mod + "==" + target + "){" + makeStatement(d - 2, b) + "}" + "{" + makeStatement(d - 2) + "}" + "}";
+}
+function weighted(wa) {
+  a = [];
+  for (var i = 0; i < wa.length; ++i) {
+    for (var j = 0; j < wa[i].w; ++j) {
+      a.push(wa[i].fun);
+    }
+  }
+  return a;
+}
+statementMakers = weighted([{
+  w: 6,
+  fun: makeBranchUnstableLoop
+}, {}]);
+(function() {
+  builderStatementMakers = weighted([{
+    w: 1,
+    fun: function() {
+      return "gc()";
+    }
+  }, {
+    w: 10,
+    fun: function() {}
+  }]);
+  makeBuilderStatement = function() {
+    return rndElt(builderStatementMakers)();
+  };
+}());
+function uniqueVarName() {
+  for (i = 0; i < 6; ++i) {
+    s = String.fromCharCode(97 + rnd(6));
+  }
+  return s;
+}
+function makeLittleStatement(d) {
+  rnd(0);
+  if (rnd) {
+    rndElt(littleStatementMakers)();
+  }
+}
+littleStatementMakers = [function() {}];
+function testOne() {
+  var code = makeOv(10);
+  tryItOut(code);
+}
+function makeStatement(d, b) {
+  if (rnd(0)) {}
+  if (rnd(2)) {
+    return makeBuilderStatement();
+  }
+  d < 6 && rnd() == 0;
+  if (d < rnd(8)) {
+    return makeLittleStatement();
+  }
+  return rndElt(statementMakers)(d, b);
+}
+function makeOv(d, B) {
+  if (rnd() == 0) {}
+  return "" + makeStatement(d, [""]);
+}
+function tryItOut(code) {
+  try {
+    f = Function(code);
+    f();
+  } catch (r) {}
+}
+for (let aa = 0; aa < 9999; aa++) {
+  testOne();
+}

js/src/jit-test/tests/auto-regress/bug739901.js

@@ -0,0 +1,20 @@
+// Binary: cache/js-dbg-64-940078281bbf-linux
+// Flags: --ion-eager
+//
+function List(l) {
+  this.l = l;
+}
+function f(p) {
+  return g(p.l);
+};
+function g(p) {
+  return !(p instanceof List) ? null : f(p.l);
+};
+list =
+  new List(new List(
+    new List(new List(
+      new List(new List(
+        new List(new List(null))))))))
+for (let i = 0; i < 99999; i++) {
+  g(list);
+}

js/src/jit-test/tests/auto-regress/bug740654.js

@@ -0,0 +1,14 @@
+// |jit-test| error:InternalError
+
+// Binary: cache/js-dbg-32-92fe907ddac8-linux
+// Flags: -m -n
+//
+mjitChunkLimit(31)
+o = {}
+o.valueOf = function() {
+    for (var p in undefined) {
+        a = new Function;
+    }
+    +o;
+};
++o;

js/src/jit-test/tests/auto-regress/bug741199.js

@@ -0,0 +1,9 @@
+// Binary: cache/js-dbg-32-e96d5b1f47b8-linux
+// Flags: --ion-eager
+//
+
+var a = new Array(1000 * 100);
+var i = a.length;
+while (i-- != 0) {}
+gc();
+(({ }).break--);

js/src/jit-test/tests/auto-regress/bug743071.js

@@ -0,0 +1,51 @@
+// Binary: cache/js-dbg-64-a9a18824b4c1-linux
+// Flags: --ion-eager
+//
+
+{
+  try
+  {
+    try
+    {
+    }
+    catch(ex1)
+    {
+    }
+  }
+  catch(ex)
+  {
+  }
+}
+function optionsClear() {
+  var optionNames = options().split(',');
+  for (var i = 0; i < optionNames.length; i++)
+  {
+    var optionName = optionNames[i];
+    if (optionName &&
+        optionName != "methodjit_always")
+    {
+      options(optionName);
+    }
+  }
+}
+{
+  optionsClear();
+  {
+  }
+}
+function test() {
+  for ( gTc=0; gTc < gTestcases.length; gTc++ ) {
+    try
+    {
+    }
+    catch(e)
+    {
+    }
+  }
+}
+try {
+var g = newGlobal('new-compartment');
+g.eval("(" + function () {
+        dbg = new Debugger(debuggeeGlobal);
+    } + ")();");
+} catch(exc0) {}

js/src/jit-test/tests/auto-regress/bug743094.js

@@ -0,0 +1,11 @@
+// |jit-test| error:InternalError
+
+// Binary: cache/js-dbg-32-a9a18824b4c1-linux
+// Flags: --ion-eager
+//
+
+gczeal(2)
+function test() {
+  typeof (new test("1")) != 'function'
+}
+test();

js/src/jit-test/tests/auto-regress/bug743096.js

@@ -0,0 +1,14 @@
+// Binary: cache/js-dbg-64-a9a18824b4c1-linux
+// Flags: --ion-eager
+//
+
+try {
+function f() {
+    var obj = {
+        p0:0, p1:1, p2:2, p3:3, p4:4, p5:5, p6:6, p7:7, p8:8, p9:9,
+        p10:0, p11:1, set:2, p13:3, p14:4, p15:5, p16:6, p17:7, p18:8, p19:9,
+        with  : function() { return 42; }
+    };
+}
+    actual = f();
+} catch(exc1) {}

js/src/jit-test/tests/auto-regress/bug746376.js

@@ -0,0 +1,70 @@
+// Binary: cache/js-dbg-64-67bf9a4a1f77-linux
+// Flags: --ion-eager
+//
+var callStack = new Array();
+var gTestcases = new Array();
+var gTc = gTestcases.length;
+function TestCase(n, d, e, a) {
+  this.expect = e;
+  this.actual = a;
+  this.passed = getTestCaseResult(e, a);
+  this.reason = '';
+  this.bugnumber = typeof(BUGNUMER) != 'undefined' ? BUGNUMBER : '';
+  this.type = (typeof window == 'undefined' ? 'shell' : 'browser');
+  gTestcases[gTc++] = this;
+}
+function reportCompare (expected, actual, description) {
+  var output = "";
+  if (typeof description == "undefined")
+  if (expected != actual)
+    printStatus ("Expected value '" + toPrinted(expected) +
+                 "' matched actual value '" + toPrinted(actual) + "'");
+  var testcase = new TestCase("unknown-test-name", description, expected, actual);
+  testcase.reason = output;
+    if (testcase.passed)     {    }
+  return testcase.passed;
+}
+function enterFunc (funcName) {
+  var lastFunc = callStack.pop();
+      reportCompare(funcName, lastFunc, "Test driver failure wrong exit function ");
+}
+function getTestCaseResult(expected, actual)
+function getFailedCases() {
+  for ( var i = 0; i < gTestcases.length; i++ ) {}
+};
+function jit(on) {}
+var lfcode = new Array();
+lfcode.push("\
+var summary = 'decompilation of \"let with with\" ';\
+var actual = '';\
+var expect = '';\
+test();\
+function test() {\
+  enterFunc ('test');\
+  gczeal(2);\
+  for (let q = 0; q < 50; ++q) {\
+    new Function('for (var i = 0; i < 5; ++i) { } ')();\
+    var w = 'r'.match(/r/);\
+    new Function('for (var j = 0; j < 1; ++j) { } ')();\
+  }\
+  jit(('Math.log'));\
+  reportCompare(expect, actual, summary);\
+}\
+");
+delete Debugger;
+while (true) {
+	var file = lfcode.shift(); if (file == undefined) { break; }
+	if (file == "evaluate") {
+	} else {
+                loadFile(file);
+	}
+}
+function loadFile(lfVarx) {
+	try {
+		if (lfVarx.substr(-3) == ".js") {
+		} else {
+			evaluate(lfVarx);
+		}
+	} catch (lfVare) {
+	}
+}

js/src/jit-test/tests/auto-regress/bug746377.js

@@ -0,0 +1,14 @@
+// |jit-test| error:InternalError
+
+// Binary: cache/js-dbg-64-67bf9a4a1f77-linux
+// Flags: --ion-eager
+//
+
+var actual = '';
+test();
+function test()
+{
+  a = {x: 1};
+  b = {__proto__: a};
+    print(actual += test(1,2,3,4));
+}

js/src/jit-test/tests/auto-regress/bug746397.js

@@ -0,0 +1,10 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-67bf9a4a1f77-linux
+// Flags: --ion-eager
+//
+
+(function () {
+  var a = ['x', 'y'];
+  obj.watch(a[+("0")], counter);
+})();

js/src/jit-test/tests/auto-regress/bug754712.js

@@ -0,0 +1,47 @@
+// Binary: cache/js-dbg-64-e8de64e7e9fe-linux
+// Flags: --ion-eager
+//
+function printStatus (msg) {}
+function printBugNumber (num) {}
+function reportCompare (expected, actual, description) {
+    printStatus ("Expected value '" + toPrinted(expected) +  "' matched actual value '" + toPrinted(actual) + "'");
+}
+try  {
+  reportCompare(expectCompile, actualCompile,  summary + ': compile actual');
+}   catch(ex)  {  }
+var lfcode = new Array();
+lfcode.push("\
+var bar = {\
+    b: 2,\
+};\
+var results = [];\
+for each (let [key, value] in Iterator(bar))\
+    results.push(key + \":\" + (results(isXMLName(), \"ok\")));\
+var expect = \"a:1;b:2\";\
+");
+lfcode.push("\
+var BUGNUMBER = 244619;\
+var summary = 'Don\\'t Crash';\
+var actual = 'Crash';\
+function f1()\
+  eval.call((enterFunc ('test')), \"var a = 'vodka'\");\
+gczeal(4);\
+reportCompare(expect, actual, summary);\
+");
+while (true) {
+	var file = lfcode.shift(); if (file == undefined) { break; }
+	if (file == "evaluate") {
+	} else {
+                loadFile(file);
+	}
+}
+function loadFile(lfVarx) {
+	try {
+		if (lfVarx.substr(-3) == ".js") {
+			switch (lfRunTypeId) {			}
+		} else {
+			evaluate(lfVarx);
+		}
+	} catch (lfVare) {
+	}
+}

js/src/jit-test/tests/auto-regress/bug754719.js

@@ -0,0 +1,10 @@
+// Binary: cache/js-dbg-64-e8de64e7e9fe-linux
+// Flags:
+//
+
+function TestCase(n, d, e, a) {}
+(function(  )  {
+    for (var i = 0; i < 64; ++i) {
+        switch (~~(TestCase) % 3) {}
+    }
+})();

js/src/jit-test/tests/auto-regress/bug755564.js

@@ -0,0 +1,9 @@
+// |jit-test| error:Error
+
+// Binary: cache/js-dbg-64-50177d59c0e1-linux
+// Flags:
+//
+
+var p = new ParallelArray([1,2,3,4,5]);
+var r = p.scatter([0,1,0,3,4], 9, function (a,b) { return a+b; });
+assertEq(r.toString( 5 ? r : 0, gc()) ,[4,2,9,4,5].join(","));

js/src/jit-test/tests/auto-regress/bug756236.js

@@ -0,0 +1,14 @@
+// Binary: cache/js-dbg-64-14735b4dbccc-linux
+// Flags: --ion-eager
+//
+
+gczeal(4);
+function startTest() {}
+function TestCase(n, d, e, a)
+    dump = (function () {});
+  if (typeof document != "object" || !document.location.href.match(/jsreftest.html/)) {}
+function writeHeaderToLog( string ) {}
+var SECTION = "11.4.5";
+new TestCase( SECTION,  "var MYVAR= void 0; --MYVAR", NaN, eval("var MYVAR=void 0; --MYVAR") );
+new TestCase( SECTION, "var MYVAR=0;--MYVAR;MYVAR", -1, eval("var MYVAR=0;--MYVAR;MYVAR") );
+new TestCase( SECTION, "var MYVAR=0;--MYVAR;MYVAR", -1, eval("var MYVAR=0;--MYVAR;MYVAR") );

js/src/jit-test/tests/auto-regress/bug757428.js

@@ -0,0 +1,11 @@
+// Binary: cache/js-dbg-64-d80602d38aa8-linux
+// Flags: --ion-eager
+//
+
+function f(o) {
+    var prop = "arguments";
+    f[prop] = f[prop];
+}
+for(var i=0; i > -10; i-- ) {
+    f(f / 16);
+}

js/src/jit-test/tests/auto-regress/bug758164.js

@@ -0,0 +1,6 @@
+// Binary: cache/js-dbg-64-407632130d1b-linux
+// Flags:
+//
+
+gc();
+evaluate("gcslice(0);");

js/src/jit-test/tests/auto-regress/bug759306.js

@@ -0,0 +1,20 @@
+// |jit-test| error:InternalError
+
+// Binary: cache/js-dbg-32-4ce3983a43f4-linux
+// Flags:
+//
+
+function assertEq(setter) {
+        if (setter > 10)
+            return {assertEq: 3.3};
+        return {__proto__: assertEq(setter + 1)};
+    }
+function testX() {
+  var x = 2;
+  var local0 = x;
+  return { local0: local0 };
+}
+var resultsX = testX();
+assertEq(resultsX.local0, 2);
+gczeal(2);
+assertEq(new (Proxy.createFunction({}, function(){}, function(){})), undefined);

js/src/jit-test/tests/auto-regress/bug759312.js

@@ -0,0 +1,60 @@
+// Binary: cache/js-dbg-32-4ce3983a43f4-linux
+// Flags: --ion-eager
+//
+try {
+  gczeal(2);
+var MyMath = {
+  random: function() {
+    this.seed = ((this.seed + 0x7ed55d16) + (this.seed << 12))  & 0xffffffff;
+    return (this.seed & 0xfffffff) / 0x10000000;
+  },
+};
+var kSplayTreeSize = 8000;
+var kSplayTreePayloadDepth = 5;
+function GeneratePayloadTree(depth, key) {
+  if (depth == 0) {
+    return {
+      array  : [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
+      string : 'String for key ' + key + ' in leaf node'
+    };
+  } else {
+    return {
+      left:  GeneratePayloadTree(depth - 1, key),
+      right: GeneratePayloadTree(depth - 1, key)
+    };
+  }
+}
+function GenerateKey() {
+  return MyMath.random();
+}
+function InsertNewNode() {
+  do {
+    key = GenerateKey();
+  } while (splayTree.find(key) != null);
+  splayTree.insert(key, GeneratePayloadTree(kSplayTreePayloadDepth, key));
+}
+function SplaySetup() {
+  splayTree = new SplayTree();
+  for (var i = 0; i < kSplayTreeSize; i++) InsertNewNode();
+}
+function SplayTree() {
+};
+SplayTree.prototype.isEmpty = function() {
+  return !this.root_;
+};
+SplayTree.prototype.insert = function(key, value) {
+  if (this.isEmpty()) {
+    this.root_ = new SplayTree.Node(key, value);
+  }
+  var node = new SplayTree.Node(key, value);
+  if (key > this.root_.key) {
+    this.root_.left = null;
+  }
+  this.root_ = node;
+};
+SplayTree.prototype.find = function(key) {};
+SplayTree.Node = function(key, value) {
+  this.key = key;
+};
+SplaySetup();
+} catch(exc1) {}

js/src/jit-test/tests/auto-regress/bug763039.js

@@ -0,0 +1,69 @@
+// Binary: cache/js-dbg-32-5cfb73435e06-linux
+// Flags: --ion-eager
+//
+var actual = '';
+function TestCase(n, d, e, a) {
+  this.reason = '';
+}
+function inSection(x) {}
+function reportCompare (expected, actual, description) {
+  var testcase = new TestCase("unknown-test-name", description, expected, actual);
+  testcase.reason = output;
+}
+var lfcode = new Array();
+lfcode.push("4");
+lfcode.push("function START(summary) {\
+}\
+function TEST(section, expected, actual) {\
+    return reportCompare(expected, actual, inSection(section) + SUMMARY);\
+}\
+var expect = (1);\
+TEST(1,1 << this <  assertEq++ < this, actual);\
+");
+lfcode.push("\
+gczeal(4);\
+data >>>=  RunSingleBenchmark(data);\
+");
+lfcode.push("4");
+lfcode.push("\
+var BUGNUMBER = 345855;\
+var summary = 'Blank yield expressions are not syntax errors';\
+test();\
+function test() {\
+  try  {\
+    eval('(function() {x = 12 + yield;})');\
+  }  catch(ex)  {}\
+  try  { eval('(function() {x = 12 + yield 42})'); }  catch(ex)  {\
+    status = inSection(4);\
+  }\
+  try  {\
+    eval('(function() {x = 12 + (yield);})');\
+  }  catch(ex)  {  }\
+  try  {\
+    eval('(function () {foo((yield))})');\
+  }  catch(ex)  {  }\
+  try  {\
+    eval('(function() {x = 12 + (yield 42)})');\
+  }  catch(ex)  {  }\
+  reportCompare(expect, actual, summary + ': function() {x = 12 + (yield 42)}');\
+}\
+");
+while (true) {
+	var file = lfcode.shift(); if (file == undefined) { break; }
+                loadFile(file);
+}
+function loadFile(lfVarx) {
+	try {
+		if (lfVarx.substr(-3) == ".js") {
+		} else if (!isNaN(lfVarx)) {
+			lfRunTypeId = lfVarx;
+		} else {
+			switch (lfRunTypeId) {
+				case 1: eval(read(lfVarx)); break;
+				default: evaluate(lfVarx);
+			}
+		}
+	} catch (lfVare) {
+		print(lfVare);
+	}
+}

js/src/jit-test/tests/auto-regress/bug763989.js

@@ -0,0 +1,47 @@
+// Binary: cache/js-dbg-32-4bcbb63b89c3-linux
+// Flags: --ion-eager
+//
+var summary = '';
+function reportFailure (msg) {}
+function toPrinted(value) {
+  value = value.replace(/\n/g, 'NL')
+}
+function reportCompare (expected, actual, description) {
+  var output = "";
+  output += "Expected value '" + toPrinted(expected) +
+      "', Actual value '" + toPrinted(actual) + "' ";
+      reportFailure (description + " : " + output);
+}
+var lfcode = new Array();
+lfcode.push("\
+  expect = actual = 'No Exception';\
+  reportCompare(expect, actual, summary);\
+");
+lfcode.push("\
+function reportFailure (section, msg)\
+  msg = inSection(section)+\"\"+msg;\
+");
+lfcode.push("\
+try {\
+  for (var i in expect) \
+    reportCompare(expect[i], actual[i], getStatus(i));\
+} catch(exc1) {}\
+function getStatus(i) {}\
+");
+lfcode.push("gczeal(2,(9));");
+lfcode.push("evaluate(\"reportCompare(expect, actual, summary);\");");
+	gcPreserveCode()
+while (true) {
+	var file = lfcode.shift(); if (file == undefined) { break; }
+	if (file == "evaluate") {
+	} else {
+                loadFile(file);
+	}
+}
+function loadFile(lfVarx) {
+	try {
+		if (lfVarx.substr(-3) != ".js") {
+			evaluate(lfVarx);
+		}
+	} catch (lfVare) {}
+}

js/src/jit-test/tests/auto-regress/bug764850.js

@@ -0,0 +1,6 @@
+// Binary: cache/js-dbg-64-7ab88528503e-linux
+// Flags:
+//
+
+gczeal(4);
+it.customNative = assertEq;

js/src/jit-test/tests/auto-regress/bug765483.js

@@ -0,0 +1,13 @@
+// |jit-test| debug; error:ReferenceError;
+
+// Binary: cache/js-dbg-64-de23a9fc29db-linux
+// Flags: --ion-eager
+//
+
+var obj1 = {}, obj2 = {};
+obj2['b'+i] = 0;
+for (var k in obj2) {
+  (function g() { evalInFrame(1, "assertStackIs(['eval-code', f, 'bound(f)', 'global-code'])", true); })();
+}
+for (var i = 0; i != array.length; ++i)
+  array[i]();

js/src/jit-test/tests/auto-regress/bug767679.js

@@ -0,0 +1,10 @@
+// Binary: cache/js-dbg-32-05a756967f25-linux
+// Flags: --ion-eager
+//
+eval("\
+    \"use strict\";\
+    a();\
+    function a() {\
+        print\
+    }\
+")

js/src/jit-test/tests/auto-regress/bug771157.js

@@ -0,0 +1,30 @@
+// Binary: cache/js-dbg-64-9cf3ea112635-linux
+// Flags: --ion-eager
+//
+
+var callStack = new Array();
+function TestCase(n, d, e, a) {
+  this.expect = e;
+  this.actual = a;
+  this.passed = getTestCaseResult(e, a);
+  dump(+ this.path + ' ' + 'reason: ' + toPrinted(this.reason)+ '\n');
+};
+function reportCompare (expected, actual, description) {
+  var testcase = new TestCase("unknown-test-name", description, expected, actual);
+}
+function enterFunc (funcName) {
+  callStack.push(funcName);
+  var lastFunc = callStack.pop();
+  reportCompare(funcName, lastFunc, "Test driver failure wrong exit function ");
+}
+try {
+var summary = 'String static methods';
+var actual = '';
+expect = '2';
+reportCompare(expect, actual, summary + " String.toUpperCase(new Boolean(true))");
+} catch(exc0) {}
+try {
+function TestCase(n, d, e, a) {}
+enterFunc ('test');
+reportCompare(expect, actual, summary);
+} catch(exc2) {}

js/src/jit-test/tests/auto-regress/bug779390.js

@@ -0,0 +1,15 @@
+// Binary: cache/js-dbg-64-b46621aba6fd-linux
+// Flags: --ion-eager
+//
+
+function TestCase(n, d, e, a) {
+  this.passed = getTestCaseResult(e, a);
+}
+function getTestCaseResult(expected, actual) {}
+try {
+for (var i = 0; i < bomchars.length; i++)
+  try {} catch(ex) {}
+} catch(exc0) {}
+["a"].map(function(s) {gczeal(4);})[0]
+new TestCase();
+new TestCase("", "", 5e-324, i);

js/src/jit-test/tests/auto-regress/bug779818.js

@@ -0,0 +1,12 @@
+// Binary: cache/js-dbg-64-2169bca0c9a5-linux
+// Flags: --ion-eager
+//
+
+var SECTION = "lexical-015";
+(function() {
+    for (var a = 0; a < 9; a++) {
+        if (SECTION[a]) {
+            while (arguments[a]) break;
+        }
+    }
+})()

js/src/jit-test/tests/auto-regress/bug780003.js

@@ -0,0 +1,6 @@
+// |jit-test| error:ReferenceError
+
+// Binary: cache/js-dbg-64-9f3dc298e25b-linux
+// Flags: --ion-eager
+//
+for(a in b){}

js/src/jit-test/tests/auto-regress/bug781364.js

@@ -0,0 +1,34 @@
+// Binary: cache/js-dbg-64-21b4797e4cb3-linux
+// Flags: -m -a --ion-eager
+//
+k = m
+function h() {
+  switch (true) {
+  default:
+    x = newGlobal('')
+  }
+  return function(f, code) {
+    try {
+      evalcx(code, x)
+    } catch (e) {}
+  }
+}
+function m() {
+  f()
+}
+function g(code) {
+  f = new Function(code);
+  k(f, code)
+}
+g("k=h()")
+g("\
+    a='';\
+    Object.defineProperty(this,\"b\",{get:function(){a=this.d()}});\
+    Object.defineProperty(this,\"c\",{get:function(){b}});\
+    d=2;\
+    b\
+");
+g("b");
+g("b");
+g("for(v of c);");
+g("a=eval(\"function f(){}\");b")

js/src/jit-test/tests/auto-regress/bug782083.js

@@ -0,0 +1,16 @@
+// Binary: cache/js-dbg-32-f1764bf06b29-linux
+// Flags: --ion-eager
+//
+
+gcPreserveCode();
+function r() {}
+gczeal(2);
+evaluate("");
+evaluate("\
+function randomFloat () {\
+    if (r < 0.25)\
+        fac = 10000000;\
+}\
+for (var i = 0; i < 100000; i++)\
+    randomFloat();\
+");

js/src/jit-test/tests/auto-regress/bug782129.js

@@ -0,0 +1,24 @@
+// Binary: cache/js-dbg-32-f1764bf06b29-linux
+// Flags: --ion-eager
+//
+
+var callStack = new Array();
+function enterFunc (funcName) {
+  funcName += "()";
+  callStack.push(funcName);
+}
+function exitFunc (funcName) {
+  var lastFunc = callStack.pop();
+  funcName += "()";
+  if (lastFunc != funcName)
+    print();
+}
+try {
+  test();
+} catch(exc1) {}
+function test() {
+  enterFunc ('test');
+  test();
+}
+for (var l = 0; l < 50000; l++)
+  exitFunc ('test');

js/src/jit-test/tests/auto-regress/bug786106.js

@@ -0,0 +1,6 @@
+// Binary: cache/js-dbg-64-92b9b2840a79-linux
+// Flags:
+//
+
+    var p = new ParallelArray([2, 3,, 4, 5, 6]);
+    var r = p.scatter([0,1,0,3,4], 9, function (a,b) { return a+b; });

js/src/jit-test/tests/auto-regress/bug827821.js

@@ -0,0 +1,36 @@
+// Binary: cache/js-dbg-32-795632f0e4fe-linux
+// Flags: --ion-eager
+//
+
+var lfcode = new Array();
+lfcode.push("3");
+lfcode.push("\
+	gczeal(2);\
+	for (let q = 0; q < 50; ++q) {\
+		var w = \"r\".match(/r/);\
+	}\
+	let (eval) (function  (a) {\
+		Function = gczeal;\
+	})();\
+	// .js\
+");
+lfcode.push(" // .js");
+lfcode.push(" // .js");
+lfcode.push(" // .js");
+while (true) {
+	var file = lfcode.shift(); if (file == undefined) { break; }
+        loadFile(file)
+}
+function loadFile(lfVarx) {
+    try {
+        if (lfVarx.substr(-3) == ".js") {
+	    uneval("foo");
+            switch (lfRunTypeId) {
+                case 3: function newFunc(x) { new Function(x)(); }; newFunc(lfVarx); break;
+                case 4: eval("(function() { " + lfVarx + " })();"); break;
+            }
+        } else if (!isNaN(lfVarx)) {
+            lfRunTypeId = parseInt(lfVarx);
+	}
+    } catch (lfVare) {}
+}

js/src/jit-test/tests/auto-regress/bug829795.js

@@ -0,0 +1,10 @@
+// |jit-test| error:TypeError
+
+// Binary: cache/js-dbg-64-44dcffe8792b-linux
+// Flags: -a
+//
+try {
+    x = [];
+    Array.prototype.forEach()
+} catch (e) {}
+x.forEach()

js/src/jit-test/tests/auto-regress/bug829813.js

@@ -0,0 +1,8 @@
+// Binary: cache/js-dbg-64-44dcffe8792b-linux
+// Flags:
+//
+for (x in [0]) {
+    (function() {
+        return Object.propertyIsEnumerable
+    })().call([0], x)
+}

js/src/jit-test/tests/auto-regress/bug830049.js

@@ -0,0 +1,14 @@
+// |jit-test| error:InternalError
+
+// Binary: cache/js-dbg-64-1761f4a9081c-linux
+// Flags: --ion-eager
+//
+
+p = Proxy.create({
+  has: function() function r() s += ''
+})
+Object.prototype.__proto__ = p
+function TestCase(n) {
+    this.name = n
+}
+new TestCase()