Bug 1063816 - Rename useCount to warmUpCounter. r=h4writer
authorNicolas B. Pierron <nicolas.b.pierron@mozilla.com>
Wed, 10 Sep 2014 19:11:20 +0200
changeset 204577 64203c2e785d342d347381725587c0c24b1a1b45
parent 204576 0703f395ca3033e4af14a086e7d9cca667b9395b
child 204578 891d587c19c4b700828bab3f41264b1d1017ad7c
push id48951
push usernpierron@mozilla.com
push dateWed, 10 Sep 2014 17:11:35 +0000
treeherdermozilla-inbound@891d587c19c4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersh4writer
bugs1063816
milestone35.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1063816 - Rename useCount to warmUpCounter. r=h4writer
js/src/gc/Zone.cpp
js/src/jit-test/lib/jitopts.js
js/src/jit-test/tests/TypedObject/jit-complex.js
js/src/jit-test/tests/TypedObject/jit-prefix.js
js/src/jit-test/tests/TypedObject/jit-read-many.js
js/src/jit-test/tests/TypedObject/jit-read-unsized.js
js/src/jit-test/tests/TypedObject/jit-write-u16-into-mdim-array.js
js/src/jit-test/tests/TypedObject/jit-write-u16-into-u16-array-in-struct.js
js/src/jit-test/tests/TypedObject/jit-write-u16-into-u16-array.js
js/src/jit-test/tests/TypedObject/jit-write-u32-into-mdim-array.js
js/src/jit-test/tests/TypedObject/jit-write-u32-into-u32-array-in-struct.js
js/src/jit-test/tests/TypedObject/jit-write-u32-into-u32-array.js
js/src/jit-test/tests/asm.js/testFFI.js
js/src/jit-test/tests/asm.js/testProfiling.js
js/src/jit-test/tests/asm.js/testStackWalking.js
js/src/jit-test/tests/baseline/bug940972.js
js/src/jit-test/tests/basic/bug970643.js
js/src/jit-test/tests/basic/testBug686274.js
js/src/jit-test/tests/bug953337.js
js/src/jit-test/tests/debug/bug1006473.js
js/src/jit-test/tests/ion/bug1000605.js
js/src/jit-test/tests/ion/bug1015498.js
js/src/jit-test/tests/ion/bug1027510.js
js/src/jit-test/tests/ion/bug1028910.js
js/src/jit-test/tests/ion/bug1054241.js
js/src/jit-test/tests/ion/bug908903.js
js/src/jit-test/tests/ion/bug915301.js
js/src/jit-test/tests/ion/bug919118.js
js/src/jit-test/tests/ion/bug939868-2.js
js/src/jit-test/tests/ion/bug977966.js
js/src/jit-test/tests/ion/bug995817.js
js/src/jit-test/tests/ion/ceil.js
js/src/jit-test/tests/ion/dce-with-rinstructions.js
js/src/jit-test/tests/ion/recover-arrays.js
js/src/jit-test/tests/ion/recover-objects.js
js/src/jit-test/tests/ion/testFloat32-correctness.js
js/src/jit-test/tests/ion/testFloat32.js
js/src/jit-test/tests/profiler/enterjit-osr-disabling-earlyret.js
js/src/jit-test/tests/profiler/enterjit-osr-disabling.js
js/src/jit-test/tests/profiler/enterjit-osr-enabling-earlyret.js
js/src/jit-test/tests/profiler/enterjit-osr-enabling.js
js/src/jit-test/tests/profiler/enterjit-osr.js
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineCompiler.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineIC.h
js/src/jit/BaselineJIT.cpp
js/src/jit/BytecodeAnalysis.cpp
js/src/jit/C1Spewer.cpp
js/src/jit/CodeGenerator.cpp
js/src/jit/Ion.cpp
js/src/jit/IonBuilder.cpp
js/src/jit/IonFrames.cpp
js/src/jit/IonOptimizationLevels.cpp
js/src/jit/JitOptions.cpp
js/src/jit/JitOptions.h
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jscompartment.cpp
js/src/jsinfer.cpp
js/src/jsopcode.cpp
js/src/jsopcodeinlines.h
js/src/jsscript.h
js/src/shell/js.cpp
js/src/vm/ForkJoin.cpp
js/src/vm/HelperThreads.cpp
js/src/vm/Interpreter-inl.h
js/xpconnect/src/XPCJSRuntime.cpp
--- a/js/src/gc/Zone.cpp
+++ b/js/src/gc/Zone.cpp
@@ -198,21 +198,21 @@ Zone::discardJitCode(FreeOp *fop)
 
             /*
              * Discard baseline script if it's not marked as active. Note that
              * this also resets the active flag.
              */
             jit::FinishDiscardBaselineScript(fop, script);
 
             /*
-             * Use counts for scripts are reset on GC. After discarding code we
+             * Warm-up counter for scripts are reset on GC. After discarding code we
              * need to let it warm back up to get information such as which
              * opcodes are setting array holes or accessing getter properties.
              */
-            script->resetUseCount();
+            script->resetWarmUpCounter();
         }
 
         jitZone()->optimizedStubSpace()->free();
     }
 }
 
 uint64_t
 Zone::gcNumber()
--- a/js/src/jit-test/lib/jitopts.js
+++ b/js/src/jit-test/lib/jitopts.js
@@ -21,49 +21,49 @@ function withJitOptions(opts, fn) {
     fn();
   } finally {
     for (var k in oldOpts)
       setJitCompilerOption(k, oldOpts[k]);
   }
 }
 
 // N.B. Ion opts *must come before* baseline opts because there's some kind of
-// "undo eager compilation" logic. If we don't set the baseline usecount
-// *after* the Ion usecount we end up setting the baseline usecount to be the
-// default if we hit the "undo eager compilation" logic.
+// "undo eager compilation" logic. If we don't set the baseline warmup-counter
+// *after* the Ion warmup-counter we end up setting the baseline warmup-counter
+// to be the default if we hit the "undo eager compilation" logic.
 var Opts_BaselineEager =
     {
       'ion.enable': 1,
       'baseline.enable': 1,
-      'baseline.usecount.trigger': 0,
+      'baseline.warmup.trigger': 0,
       'offthread-compilation.enable': 1
     };
 
 // Checking for offthread compilation being off is often helpful if the test
 // requires a function be Ion compiled. Each individual test will usually
 // finish before the Ion compilation thread has a chance to attach the
 // compiled code.
 var Opts_IonEagerNoOffthreadCompilation =
     {
       'ion.enable': 1,
-      'ion.usecount.trigger': 0,
+      'ion.warmup.trigger': 0,
       'baseline.enable': 1,
-      'baseline.usecount.trigger': 0,
+      'baseline.warmup.trigger': 0,
       'offthread-compilation.enable': 0,
     };
 
 var Opts_Ion2NoOffthreadCompilation =
     {
       'ion.enable': 1,
-      'ion.usecount.trigger': 2,
+      'ion.warmup.trigger': 2,
       'baseline.enable': 1,
-      'baseline.usecount.trigger': 1,
+      'baseline.warmup.trigger': 1,
       'offthread-compilation.enable': 0
     };
 
 var Opts_NoJits =
     {
       'ion.enable': 0,
-      'ion.usecount.trigger': 0,
-      'baseline.usecount.trigger': 0,
+      'ion.warmup.trigger': 0,
+      'baseline.warmup.trigger': 0,
       'baseline.enable': 0,
       'offthread-compilation.enable': 0
     };
--- a/js/src/jit-test/tests/TypedObject/jit-complex.js
+++ b/js/src/jit-test/tests/TypedObject/jit-complex.js
@@ -1,15 +1,15 @@
 // Test that we can optimize stuff like line.target.x without
 // creating an intermediate object.
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var PointType = new TypedObject.StructType({x: TypedObject.float64,
                                             y: TypedObject.float64});
 var LineType = new TypedObject.StructType({source: PointType,
                                            target: PointType});
 
 function manhattanDistance(line) {
   return (Math.abs(line.target.x - line.source.x) +
--- a/js/src/jit-test/tests/TypedObject/jit-prefix.js
+++ b/js/src/jit-test/tests/TypedObject/jit-prefix.js
@@ -1,12 +1,12 @@
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var PointType2 =
   new TypedObject.StructType({
     x: TypedObject.float64,
     y: TypedObject.float64});
 
 var PointType3 =
   new TypedObject.StructType({
--- a/js/src/jit-test/tests/TypedObject/jit-read-many.js
+++ b/js/src/jit-test/tests/TypedObject/jit-read-many.js
@@ -4,17 +4,17 @@
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
 // Test a single function (`bar`) being used with arrays that are all
 // of known length, but not the same length.
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var N0 = 50;
 var N1 = 100;
 var N2 = 150;
 var T = TypedObject;
 var Array0 = T.uint32.array(N0);
 var Array1 = T.uint32.array(N1);
 var Array2 = T.uint32.array(N2);
--- a/js/src/jit-test/tests/TypedObject/jit-read-unsized.js
+++ b/js/src/jit-test/tests/TypedObject/jit-read-unsized.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var N = 100;
 var T = TypedObject;
 var Point = new T.StructType({x: T.uint32, y: T.uint32, z: T.uint32});
 var PointArray = Point.array();
 
 function bar(array, i, x, y, z) {
   assertEq(array[i].x, x);
--- a/js/src/jit-test/tests/TypedObject/jit-write-u16-into-mdim-array.js
+++ b/js/src/jit-test/tests/TypedObject/jit-write-u16-into-mdim-array.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var PointType = TypedObject.uint16.array(3);
 var VecPointType = PointType.array(3);
 
 function foo() {
   for (var i = 0; i < 5000; i += 10) {
     var vec = new VecPointType();
 
--- a/js/src/jit-test/tests/TypedObject/jit-write-u16-into-u16-array-in-struct.js
+++ b/js/src/jit-test/tests/TypedObject/jit-write-u16-into-u16-array-in-struct.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var Vec3u16Type = TypedObject.uint16.array(3);
 var PairVec3u16Type = new TypedObject.StructType({fst: Vec3u16Type,
                                                   snd: Vec3u16Type});
 
 function foo_u16() {
   for (var i = 0; i < 5000; i += 10) {
     var p = new PairVec3u16Type();
--- a/js/src/jit-test/tests/TypedObject/jit-write-u16-into-u16-array.js
+++ b/js/src/jit-test/tests/TypedObject/jit-write-u16-into-u16-array.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var Vec3u16Type = TypedObject.uint16.array(3);
 
 function foo_u16() {
   for (var i = 0; i < 5000; i += 10) {
     var vec = new Vec3u16Type();
     // making index non-trivially dependent on |i| to foil compiler optimization
     vec[(i)     % 3] = i;
--- a/js/src/jit-test/tests/TypedObject/jit-write-u32-into-mdim-array.js
+++ b/js/src/jit-test/tests/TypedObject/jit-write-u32-into-mdim-array.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var PointType = TypedObject.uint32.array(3);
 var VecPointType = PointType.array(3);
 
 function foo() {
   for (var i = 0; i < 5000; i += 10) {
     var vec = new VecPointType();
 
--- a/js/src/jit-test/tests/TypedObject/jit-write-u32-into-u32-array-in-struct.js
+++ b/js/src/jit-test/tests/TypedObject/jit-write-u32-into-u32-array-in-struct.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var Vec3u32Type = TypedObject.uint32.array(3);
 var PairVec3u32Type = new TypedObject.StructType({fst: Vec3u32Type,
                                                   snd: Vec3u32Type});
 
 function foo_u32() {
   for (var i = 0; i < 5000; i += 10) {
     var p = new PairVec3u32Type();
--- a/js/src/jit-test/tests/TypedObject/jit-write-u32-into-u32-array.js
+++ b/js/src/jit-test/tests/TypedObject/jit-write-u32-into-u32-array.js
@@ -1,17 +1,17 @@
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 
 if (!this.hasOwnProperty("TypedObject"))
   quit();
 
-setJitCompilerOption("ion.usecount.trigger", 30);
+setJitCompilerOption("ion.warmup.trigger", 30);
 
 var Vec3u32Type = TypedObject.uint32.array(3);
 
 function foo_u32() {
   for (var i = 0; i < 5000; i += 10) {
     var vec = new Vec3u32Type();
     // making index non-trivially dependent on |i| to foil compiler optimization
     vec[(i)     % 3] = i;
--- a/js/src/jit-test/tests/asm.js/testFFI.js
+++ b/js/src/jit-test/tests/asm.js/testFFI.js
@@ -93,18 +93,18 @@ var recurse = function(i,j) { if (i == 0
 var f = asmLink(asmCompile('glob', 'imp', USE_ASM + 'var ffi=imp.ffi; function g(i,j,k) { i=i|0;j=+j;k=k|0; if (!(k|0)) ffi(i|0,j)|0; else g(i, j+1.0, (k-1)|0) } function f(i,j) { i=i|0;j=+j; g(i,j,4) } return f'), null, {ffi:recurse});
 assertThrowsValue(function() { f(0,2.4) }, 2.4+4);
 assertThrowsValue(function() { f(1,2.4) }, 2.4+8);
 assertThrowsValue(function() { f(8,2.4) }, 2.4+36);
 
 assertEq(asmLink(asmCompile('glob', 'imp', USE_ASM + 'var identity=imp.identity; function g(x) { x=+x; return +identity(x) } return g'), null, imp)(13.37), 13.37);
 
 // Test asm.js => ion paths
-setJitCompilerOption("ion.usecount.trigger", 10);
-setJitCompilerOption("baseline.usecount.trigger", 0);
+setJitCompilerOption("ion.warmup.trigger", 10);
+setJitCompilerOption("baseline.warmup.trigger", 0);
 setJitCompilerOption("offthread-compilation.enable", 0);
 
 // In registers on x64 and ARM, on the stack for x86
 function ffiIntFew(a,b,c,d) { return d+1 }
 var f = asmLink(asmCompile('glob', 'imp', USE_ASM + 'var ffi=imp.ffi; function f(i) { i=i|0; return ffi(i|0,(i+1)|0,(i+2)|0,(i+3)|0)|0 } return f'), null, {ffi:ffiIntFew});
 for (var i = 0; i < 40; i++)
     assertEq(f(i), i+4);
 
--- a/js/src/jit-test/tests/asm.js/testProfiling.js
+++ b/js/src/jit-test/tests/asm.js/testProfiling.js
@@ -83,18 +83,18 @@ function testBuiltinDD2D(name) {
     assertEq(f(.1, .2), eval("Math." + name + "(.1, .2)"));
     var stacks = disableSingleStepProfiling();
     assertEqualStacks(stacks, ",>,f>,Math." + name + "f>,f>,>,");
 }
 for (name of ['atan2', 'pow'])
     testBuiltinDD2D(name);
 
 // FFI tests:
-setJitCompilerOption("ion.usecount.trigger", 10);
-setJitCompilerOption("baseline.usecount.trigger", 0);
+setJitCompilerOption("ion.warmup.trigger", 10);
+setJitCompilerOption("baseline.warmup.trigger", 0);
 setJitCompilerOption("offthread-compilation.enable", 0);
 
 var ffi1 = function() { return 10 }
 var ffi2 = function() { return 73 }
 var f = asmLink(asmCompile('g','ffis', USE_ASM + "var ffi1=ffis.ffi1, ffi2=ffis.ffi2; function f() { return ((ffi1()|0) + (ffi2()|0))|0 } return f"), null, {ffi1,ffi2});
 // Interpreter FFI exit
 enableSingleStepProfiling();
 assertEq(f(), 83);
--- a/js/src/jit-test/tests/asm.js/testStackWalking.js
+++ b/js/src/jit-test/tests/asm.js/testStackWalking.js
@@ -12,18 +12,18 @@ function matchStack(stackString, stackAr
 }
 
 var stack;
 function dumpStack()
 {
     stack = new Error().stack
 }
 
-setJitCompilerOption("ion.usecount.trigger", 10);
-setJitCompilerOption("baseline.usecount.trigger", 0);
+setJitCompilerOption("ion.warmup.trigger", 10);
+setJitCompilerOption("baseline.warmup.trigger", 0);
 setJitCompilerOption("offthread-compilation.enable", 0);
 setCachingEnabled(true);
 
 var callFFI = asmCompile('global', 'ffis', USE_ASM + "var ffi=ffis.ffi; function f() { return ffi()|0 } return f");
 
 var f = asmLink(callFFI, null, {ffi:dumpStack});
 for (var i = 0; i < 15; i++) {
     stack = null;
--- a/js/src/jit-test/tests/baseline/bug940972.js
+++ b/js/src/jit-test/tests/baseline/bug940972.js
@@ -1,5 +1,5 @@
-setJitCompilerOption("baseline.usecount.trigger", 0);
+setJitCompilerOption("baseline.warmup.trigger", 0);
 var arr = new Uint8ClampedArray(1);
 for (var i = 0; i < 2; ++i)
     arr[0] = 4294967296;
 assertEq(arr[0], 255);
--- a/js/src/jit-test/tests/basic/bug970643.js
+++ b/js/src/jit-test/tests/basic/bug970643.js
@@ -1,12 +1,12 @@
 // |jit-test| exitstatus: 6;
 
-setJitCompilerOption("baseline.usecount.trigger", 1);
-setJitCompilerOption("ion.usecount.trigger", 2);
+setJitCompilerOption("baseline.warmup.trigger", 1);
+setJitCompilerOption("ion.warmup.trigger", 2);
 
 // The timepout function is made to trigger the interruption callback. The
 // interruption callback will protect the code while a GC might be
 // marking/updating pointers in it.
 var x = 0;
 function interrupt_gc() {
   if (x++ >= 20)
     return;
--- a/js/src/jit-test/tests/basic/testBug686274.js
+++ b/js/src/jit-test/tests/basic/testBug686274.js
@@ -1,11 +1,11 @@
 // Don't Baseline-compile the huge array literal with --baseline-eager
 // as it's slow, especially in debug builds.
-setJitCompilerOption("baseline.usecount.trigger", 2);
+setJitCompilerOption("baseline.warmup.trigger", 2);
 
 function f(N) {
     var body = "return [";
     for (var i = 0; i < N-1; i++)
         body += "1,";
     body += "2]";
     var f = new Function(body);
     var arr = f();
--- a/js/src/jit-test/tests/bug953337.js
+++ b/js/src/jit-test/tests/bug953337.js
@@ -1,8 +1,8 @@
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("ion.warmup.trigger", 20);
 Function.prototype.__proto__ = new Boolean({ get: function() {} }, {});
 function g(x, y) {}
 function f() {
     g.apply(this, arguments);
 }
 for (var i = 0; i < 130; ++i)
     f(i, i*2);
--- a/js/src/jit-test/tests/debug/bug1006473.js
+++ b/js/src/jit-test/tests/debug/bug1006473.js
@@ -1,13 +1,13 @@
 // |jit-test| error: ReferenceError
 
 var lfcode = new Array();
 lfcode.push("gczeal(4);");
-lfcode.push("setJitCompilerOption('ion.usecount.trigger', 30);");
+lfcode.push("setJitCompilerOption('ion.warmup.trigger', 30);");
 lfcode.push("\
 var g = newGlobal();\
 g.parent = this;\
 g.eval('function f(frame, exc) { f2 = function () { return exc; }; exc = 123; }');\
 g.eval('new Debugger(parent).onExceptionUnwind = f;');\
 var obj = int8  ('oops');\
 ");
 while (true) {
--- a/js/src/jit-test/tests/ion/bug1000605.js
+++ b/js/src/jit-test/tests/ion/bug1000605.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 0);
-setJitCompilerOption("ion.usecount.trigger", 0);
+setJitCompilerOption("baseline.warmup.trigger", 0);
+setJitCompilerOption("ion.warmup.trigger", 0);
 
 function ceil(a, b) {
     return Math.ceil((a | 0) / (b | 0)) | 0;
 }
 function floor(a, b) {
     return Math.floor((a | 0) / (b | 0)) | 0;
 }
 function round(a, b) {
--- a/js/src/jit-test/tests/ion/bug1015498.js
+++ b/js/src/jit-test/tests/ion/bug1015498.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 function myFloor(x) {
     if(x >= 0)
         return x - Math.abs(x % 1);
     else
         return x - Math.abs(1 + (x % 1));
 }
 
--- a/js/src/jit-test/tests/ion/bug1027510.js
+++ b/js/src/jit-test/tests/ion/bug1027510.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 function myCeil(x) {
     if(x >= 0) {
         var r = Math.abs(x % 1);
         if(r != 0)
             return (x + 1) - r;
         else
             return x;
--- a/js/src/jit-test/tests/ion/bug1028910.js
+++ b/js/src/jit-test/tests/ion/bug1028910.js
@@ -1,9 +1,9 @@
-setJitCompilerOption("ion.usecount.trigger", 4);
+setJitCompilerOption("ion.warmup.trigger", 4);
 
 var IsObject = getSelfHostedValue("IsObject")
 function test(foo) {
     if (IsObject(foo)) {
         print(foo.test)
     }
 
 }
--- a/js/src/jit-test/tests/ion/bug1054241.js
+++ b/js/src/jit-test/tests/ion/bug1054241.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 setObjectMetadataCallback(true);
 (function(){
   for(var i = 0; i < 100; i++) {
     try{
       var a = new Array(5);
       throw 1;
     } catch(e) {}
--- a/js/src/jit-test/tests/ion/bug908903.js
+++ b/js/src/jit-test/tests/ion/bug908903.js
@@ -1,28 +1,28 @@
 
 function f(x) {
     return x + 1;
 }
 
-setJitCompilerOption("ion.usecount.trigger", 2);
-setJitCompilerOption("baseline.usecount.trigger", 0);
+setJitCompilerOption("ion.warmup.trigger", 2);
+setJitCompilerOption("baseline.warmup.trigger", 0);
 
-assertEq(f(1), 2);     // usecount == 1 => eagerly compile with baseline.
-assertEq(f(0.5), 1.5); // usecount == 2 => normaly compile with ion.
-                       //                  invalidate for unexpect output.
+assertEq(f(1), 2);     // warm-up == 1 => eagerly compile with baseline.
+assertEq(f(0.5), 1.5); // warm-up == 2 => normaly compile with ion.
+                       //                 invalidate for unexpect output.
 
 
 function normal() {
-    setJitCompilerOption("ion.usecount.trigger", 8);
-    setJitCompilerOption("baseline.usecount.trigger", 5);
+    setJitCompilerOption("ion.warmup.trigger", 8);
+    setJitCompilerOption("baseline.warmup.trigger", 5);
 }
 
 function eager() {
-    setJitCompilerOption("ion.usecount.trigger", 0);
+    setJitCompilerOption("ion.warmup.trigger", 0);
 }
 
 function h(x) {
     return x + 1;
 }
 
 function g(x) {
     normal();
@@ -38,17 +38,17 @@ for (var i = 0; i < 10; i++) {
 
 // Check for wrong arguments.
 try {
     setJitCompilerOption("not.an.option", 51);
     assertEq(false, true);
 } catch (x) { }
 
 try {
-    var ion = { usecount: { trigger: null } };
-    setJitCompilerOption(ion.usecount.trigger, 42);
+    var ion = { warmup: { trigger: null } };
+    setJitCompilerOption(ion.warmup.trigger, 42);
     assertEq(false, true);
 } catch (x) { }
 
 try {
-    setJitCompilerOption("ion.usecount.trigger", "32");
+    setJitCompilerOption("ion.warmup.trigger", "32");
     assertEq(false, true);
 } catch (x) { }
--- a/js/src/jit-test/tests/ion/bug915301.js
+++ b/js/src/jit-test/tests/ion/bug915301.js
@@ -1,9 +1,9 @@
-setJitCompilerOption("ion.usecount.trigger", 50);
+setJitCompilerOption("ion.warmup.trigger", 50);
 var f32 = new Float32Array(32);
 f32[0] = 0;
 
 function g(x) {
     eval(""); // don't inline
     return x + 4;
 }
 
--- a/js/src/jit-test/tests/ion/bug919118.js
+++ b/js/src/jit-test/tests/ion/bug919118.js
@@ -1,9 +1,9 @@
-setJitCompilerOption("ion.usecount.trigger", 50);
+setJitCompilerOption("ion.warmup.trigger", 50);
 
 var f32 = new Float32Array(1);
 f32[0] = 13;
 var str = "CAN HAS cheezburger? OKTHXBYE";
 var c;
 
 function f() {
     c = str[ f32[0] ];
--- a/js/src/jit-test/tests/ion/bug939868-2.js
+++ b/js/src/jit-test/tests/ion/bug939868-2.js
@@ -27,17 +27,17 @@ function g(x,y,z) {
     } else {
         z = Math.fround(z);
         assertFloat32(z, true);
     }
     assertFloat32(z, true);
     return z;
 }
 
-setJitCompilerOption("ion.usecount.trigger", 50);
+setJitCompilerOption("ion.warmup.trigger", 50);
 
 for (var n = 100; n--; ) {
     assertEq(f(0,1,2), 2);
     assertEq(f(0,0,2), 2);
     assertEq(f(1,0,2), 0xfffffff);
     assertEq(f(1,1,2), 0xfffffff);
 
     assertEq(g(0,1,2), 2);
--- a/js/src/jit-test/tests/ion/bug977966.js
+++ b/js/src/jit-test/tests/ion/bug977966.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 function join_check() {
     var lengthWasCalled = false;
     var obj = {"0": "", "1": ""};
     Object.defineProperty(obj, "length", {
         get : function(){ lengthWasCalled = true; return 2; },
         enumerable : true,
         configurable : true
--- a/js/src/jit-test/tests/ion/bug995817.js
+++ b/js/src/jit-test/tests/ion/bug995817.js
@@ -1,9 +1,9 @@
-setJitCompilerOption('baseline.usecount.trigger', 1);
+setJitCompilerOption('baseline.warmup.trigger', 1);
 let r;
 (function() {
      function f() {
          return (1 + -1 / 0) << null;
      }
      assertEq(f(), 0);
      assertEq(f(), 0);
 
--- a/js/src/jit-test/tests/ion/ceil.js
+++ b/js/src/jit-test/tests/ion/ceil.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 //var log = print;
 var log = function(x){}
 
 function ceil(x) {
     // A nice but not always efficient polyfill.
     return -Math.floor(-x);
 }
--- a/js/src/jit-test/tests/ion/dce-with-rinstructions.js
+++ b/js/src/jit-test/tests/ion/dce-with-rinstructions.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 var i;
 
 // Check that we are able to remove the operation inside recover test functions (denoted by "rop..."),
 // when we inline the first version of uceFault, and ensure that the bailout is correct
 // when uceFault is replaced (which cause an invalidation bailout)
 
 var uceFault = function (i) {
     if (i > 98)
--- a/js/src/jit-test/tests/ion/recover-arrays.js
+++ b/js/src/jit-test/tests/ion/recover-arrays.js
@@ -1,10 +1,10 @@
-//setJitCompilerOption("baseline.usecount.trigger", 10);
-//setJitCompilerOption("ion.usecount.trigger", 20);
+//setJitCompilerOption("baseline.warmup.trigger", 10);
+//setJitCompilerOption("ion.warmup.trigger", 20);
 
 // This function is used to force a bailout when it is inlined, and to recover
 // the frame which is inlining this function.
 var resumeHere = function (i) { if (i >= 99) bailout(); };
 
 // This function is used to cause an invalidation after having removed a branch
 // after DCE.  This is made to check if we correctly recover an array
 // allocation.
--- a/js/src/jit-test/tests/ion/recover-objects.js
+++ b/js/src/jit-test/tests/ion/recover-objects.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 var uceFault = function (i) {
     if (i > 98)
         uceFault = function (i) { return true; };
     return false;
 };
 
 // Without "use script" in the inner function, the arguments might be
--- a/js/src/jit-test/tests/ion/testFloat32-correctness.js
+++ b/js/src/jit-test/tests/ion/testFloat32-correctness.js
@@ -1,9 +1,9 @@
-setJitCompilerOption("ion.usecount.trigger", 50);
+setJitCompilerOption("ion.warmup.trigger", 50);
 
 var f32 = new Float32Array(10);
 
 function test(setup, f) {
     if (f === undefined) {
         f = setup;
         setup = function(){};
     }
--- a/js/src/jit-test/tests/ion/testFloat32.js
+++ b/js/src/jit-test/tests/ion/testFloat32.js
@@ -46,18 +46,19 @@
 //
 // ION TESTS
 //
 // The assertFloat32 function is deactivated in --ion-eager mode, as the first time, the function Math.fround
 // would be guarded against modifications (typeguard on Math and then on fround). In this case, Math.fround is
 // not inlined and the compiler will consider the return value to be a double, not a float32, making the
 // assertions fail. Note that as assertFloat32 is declared unsafe for fuzzing, this can't happen in fuzzed code.
 //
-// To be able to test it, we still need ion compilation though. A nice solution is to manually lower the ion usecount.
-setJitCompilerOption("ion.usecount.trigger", 50);
+// To be able to test it, we still need ion compilation though. A nice solution
+// is to manually lower the ion warm-up trigger.
+setJitCompilerOption("ion.warmup.trigger", 50);
 
 function test(f) {
     f32[0] = .5;
     for(var n = 110; n; n--)
         f();
 }
 
 var f32 = new Float32Array(2);
--- a/js/src/jit-test/tests/profiler/enterjit-osr-disabling-earlyret.js
+++ b/js/src/jit-test/tests/profiler/enterjit-osr-disabling-earlyret.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 enableSPSProfilingWithSlowAssertions();
 (function() {
    var n = 50;
    while (n--) {
        disableSPSProfiling();
        if (!n)
 	   return;
--- a/js/src/jit-test/tests/profiler/enterjit-osr-disabling.js
+++ b/js/src/jit-test/tests/profiler/enterjit-osr-disabling.js
@@ -1,9 +1,9 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 enableSPSProfilingWithSlowAssertions();
 (function() {
    disableSPSProfiling();
    var n = 50;
    while (n--);
 })();
--- a/js/src/jit-test/tests/profiler/enterjit-osr-enabling-earlyret.js
+++ b/js/src/jit-test/tests/profiler/enterjit-osr-enabling-earlyret.js
@@ -1,10 +1,10 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 (function() {
    var n = 50;
    while (n--) {
        enableSPSProfilingWithSlowAssertions();
        if (!n)
 	   return;
        disableSPSProfiling();
--- a/js/src/jit-test/tests/profiler/enterjit-osr-enabling.js
+++ b/js/src/jit-test/tests/profiler/enterjit-osr-enabling.js
@@ -1,8 +1,8 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 (function() {
    enableSPSProfilingWithSlowAssertions();
    var n = 50;
    while (n--);
 })();
--- a/js/src/jit-test/tests/profiler/enterjit-osr.js
+++ b/js/src/jit-test/tests/profiler/enterjit-osr.js
@@ -1,8 +1,8 @@
-setJitCompilerOption("baseline.usecount.trigger", 10);
-setJitCompilerOption("ion.usecount.trigger", 20);
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
 
 enableSPSProfilingWithSlowAssertions();
 (function() {
    var n = 50;
    while (n--);
 })();
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -1664,18 +1664,18 @@ jit::FinishBailoutToBaseline(BaselineBai
 
         // After copying from all the rematerialized frames, remove them from
         // the table to keep the table up to date.
         act->removeRematerializedFrame(outerFp);
     }
 
     JitSpew(JitSpew_BaselineBailouts,
             "  Restored outerScript=(%s:%u,%u) innerScript=(%s:%u,%u) (bailoutKind=%u)",
-            outerScript->filename(), outerScript->lineno(), outerScript->getUseCount(),
-            innerScript->filename(), innerScript->lineno(), innerScript->getUseCount(),
+            outerScript->filename(), outerScript->lineno(), outerScript->getWarmUpCounter(),
+            innerScript->filename(), innerScript->lineno(), innerScript->getWarmUpCounter(),
             (unsigned) bailoutKind);
 
     switch (bailoutKind) {
       // Normal bailouts.
       case Bailout_Inevitable:
       case Bailout_DuringVMCall:
       case Bailout_NonJSFunctionCallee:
       case Bailout_DynamicNameNotFound:
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -374,17 +374,17 @@ BaselineCompiler::emitPrologue()
         return false;
 
     if (!emitStackCheck())
         return false;
 
     if (!emitDebugPrologue())
         return false;
 
-    if (!emitUseCountIncrement())
+    if (!emitWarmUpCounterIncrement())
         return false;
 
     if (!emitArgumentTypeChecks())
         return false;
 
     if (!emitSPSPush())
         return false;
 
@@ -642,35 +642,35 @@ BaselineCompiler::emitInterruptCheck()
     if (!callVM(InterruptCheckInfo))
         return false;
 
     masm.bind(&done);
     return true;
 }
 
 bool
-BaselineCompiler::emitUseCountIncrement(bool allowOsr)
+BaselineCompiler::emitWarmUpCounterIncrement(bool allowOsr)
 {
-    // Emit no use count increments or bailouts if Ion is not
+    // Emit no warm-up counter increments or bailouts if Ion is not
     // enabled, or if the script will never be Ion-compileable
 
     if (!ionCompileable_ && !ionOSRCompileable_)
         return true;
 
     Register scriptReg = R2.scratchReg();
     Register countReg = R0.scratchReg();
-    Address useCountAddr(scriptReg, JSScript::offsetOfUseCount());
+    Address warmUpCounterAddr(scriptReg, JSScript::offsetOfWarmUpCounter());
 
     masm.movePtr(ImmGCPtr(script), scriptReg);
-    masm.load32(useCountAddr, countReg);
+    masm.load32(warmUpCounterAddr, countReg);
     masm.add32(Imm32(1), countReg);
-    masm.store32(countReg, useCountAddr);
-
-    // If this is a loop inside a catch or finally block, increment the use
-    // count but don't attempt OSR (Ion only compiles the try block).
+    masm.store32(countReg, warmUpCounterAddr);
+
+    // If this is a loop inside a catch or finally block, increment the warmup
+    // counter but don't attempt OSR (Ion only compiles the try block).
     if (analysis_.info(pc).loopEntryInCatchOrFinally) {
         JS_ASSERT(JSOp(*pc) == JSOP_LOOPENTRY);
         return true;
     }
 
     // OSR not possible at this loop entry.
     if (!allowOsr) {
         JS_ASSERT(JSOp(*pc) == JSOP_LOOPENTRY);
@@ -683,17 +683,17 @@ BaselineCompiler::emitUseCountIncrement(
     uint32_t minUses = info->usesBeforeCompile(script, pc);
     masm.branch32(Assembler::LessThan, countReg, Imm32(minUses), &skipCall);
 
     masm.branchPtr(Assembler::Equal,
                    Address(scriptReg, JSScript::offsetOfIonScript()),
                    ImmPtr(ION_COMPILING_SCRIPT), &skipCall);
 
     // Call IC.
-    ICUseCount_Fallback::Compiler stubCompiler(cx);
+    ICWarmUpCounter_Fallback::Compiler stubCompiler(cx);
     if (!emitNonOpIC(stubCompiler.getStub(&stubSpace_)))
         return false;
 
     masm.bind(&skipCall);
 
     return true;
 }
 
@@ -1100,17 +1100,17 @@ BaselineCompiler::emit_JSOP_LOOPHEAD()
 {
     return emitInterruptCheck();
 }
 
 bool
 BaselineCompiler::emit_JSOP_LOOPENTRY()
 {
     frame.syncStack(0);
-    return emitUseCountIncrement(LoopEntryCanIonOsr(pc));
+    return emitWarmUpCounterIncrement(LoopEntryCanIonOsr(pc));
 }
 
 bool
 BaselineCompiler::emit_JSOP_VOID()
 {
     frame.pop();
     frame.push(UndefinedValue());
     return true;
--- a/js/src/jit/BaselineCompiler.h
+++ b/js/src/jit/BaselineCompiler.h
@@ -224,17 +224,17 @@ class BaselineCompiler : public Baseline
         return emitIC(stub, ICEntry::Kind_Op);
     }
     bool emitNonOpIC(ICStub *stub) {
         return emitIC(stub, ICEntry::Kind_NonOp);
     }
 
     bool emitStackCheck(bool earlyCheck=false);
     bool emitInterruptCheck();
-    bool emitUseCountIncrement(bool allowOsr=true);
+    bool emitWarmUpCounterIncrement(bool allowOsr=true);
     bool emitArgumentTypeChecks();
     bool emitDebugPrologue();
     bool emitDebugTrap();
     bool emitSPSPush();
     void emitSPSPop();
 
     bool initScopeChain();
 
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -53,17 +53,17 @@ FallbackICSpew(JSContext *cx, ICFallback
         va_end(args);
 
         JitSpew(JitSpew_BaselineICFallback,
                 "Fallback hit for (%s:%d) (pc=%d,line=%d,uses=%d,stubs=%d): %s",
                 script->filename(),
                 script->lineno(),
                 (int) script->pcToOffset(pc),
                 PCToLineNumber(script, pc),
-                script->getUseCount(),
+                script->getWarmUpCounter(),
                 (int) stub->numOptimizedStubs(),
                 fmtbuf);
     }
 }
 
 void
 TypeFallbackICSpew(JSContext *cx, ICTypeMonitor_Fallback *stub, const char *fmt, ...)
 {
@@ -78,17 +78,17 @@ TypeFallbackICSpew(JSContext *cx, ICType
         va_end(args);
 
         JitSpew(JitSpew_BaselineICFallback,
                 "Type monitor fallback hit for (%s:%d) (pc=%d,line=%d,uses=%d,stubs=%d): %s",
                 script->filename(),
                 script->lineno(),
                 (int) script->pcToOffset(pc),
                 PCToLineNumber(script, pc),
-                script->getUseCount(),
+                script->getWarmUpCounter(),
                 (int) stub->numOptimizedMonitorStubs(),
                 fmtbuf);
     }
 }
 
 #else
 #define FallbackICSpew(...)
 #define TypeFallbackICSpew(...)
@@ -771,21 +771,21 @@ ICStubCompiler::emitPostWriteBarrierSlot
     masm.PopRegsInMask(saveRegs);
 
     masm.bind(&skipBarrier);
     return true;
 }
 #endif // JSGC_GENERATIONAL
 
 //
-// UseCount_Fallback
+// WarmUpCounter_Fallback
 //
 
 static bool
-EnsureCanEnterIon(JSContext *cx, ICUseCount_Fallback *stub, BaselineFrame *frame,
+EnsureCanEnterIon(JSContext *cx, ICWarmUpCounter_Fallback *stub, BaselineFrame *frame,
                   HandleScript script, jsbytecode *pc, void **jitcodePtr)
 {
     JS_ASSERT(jitcodePtr);
     JS_ASSERT(!*jitcodePtr);
 
     bool isLoopEntry = (JSOp(*pc) == JSOP_LOOPENTRY);
 
     MethodStatus stat;
@@ -809,26 +809,26 @@ EnsureCanEnterIon(JSContext *cx, ICUseCo
         JitSpew(JitSpew_BaselineOSR, "  Can't compile with Ion!");
     else if (stat == Method_Skipped)
         JitSpew(JitSpew_BaselineOSR, "  Skipped compile with Ion!");
     else if (stat == Method_Compiled)
         JitSpew(JitSpew_BaselineOSR, "  Compiled with Ion!");
     else
         MOZ_CRASH("Invalid MethodStatus!");
 
-    // Failed to compile.  Reset use count and return.
+    // Failed to compile.  Reset warm-up counter and return.
     if (stat != Method_Compiled) {
-        // TODO: If stat == Method_CantCompile, insert stub that just skips the useCount
-        // entirely, instead of resetting it.
+        // TODO: If stat == Method_CantCompile, insert stub that just skips the
+        // warm-up counter entirely, instead of resetting it.
         bool bailoutExpected = script->hasIonScript() && script->ionScript()->bailoutExpected();
         if (stat == Method_CantCompile || bailoutExpected) {
-            JitSpew(JitSpew_BaselineOSR, "  Reset UseCount cantCompile=%s bailoutExpected=%s!",
+            JitSpew(JitSpew_BaselineOSR, "  Reset WarmUpCounter cantCompile=%s bailoutExpected=%s!",
                     stat == Method_CantCompile ? "yes" : "no",
                     bailoutExpected ? "yes" : "no");
-            script->resetUseCount();
+            script->resetWarmUpCounter();
         }
         return true;
     }
 
     if (isLoopEntry) {
         IonScript *ion = script->ionScript();
         JS_ASSERT(cx->runtime()->spsProfiler.enabled() == ion->hasSPSInstrumentation());
         JS_ASSERT(ion->osrPc() == pc);
@@ -870,17 +870,17 @@ EnsureCanEnterIon(JSContext *cx, ICUseCo
 
 struct IonOsrTempData
 {
     void *jitcode;
     uint8_t *baselineFrame;
 };
 
 static IonOsrTempData *
-PrepareOsrTempData(JSContext *cx, ICUseCount_Fallback *stub, BaselineFrame *frame,
+PrepareOsrTempData(JSContext *cx, ICWarmUpCounter_Fallback *stub, BaselineFrame *frame,
                    HandleScript script, jsbytecode *pc, void *jitcode)
 {
     size_t numLocalsAndStackVals = frame->numValueSlots();
 
     // Calculate the amount of space to allocate:
     //      BaselineFrame space:
     //          (sizeof(Value) * (numLocals + numStackVals))
     //        + sizeof(BaselineFrame)
@@ -915,39 +915,39 @@ PrepareOsrTempData(JSContext *cx, ICUseC
     JitSpew(JitSpew_BaselineOSR, "Allocated IonOsrTempData at %p", (void *) info);
     JitSpew(JitSpew_BaselineOSR, "Jitcode is %p", info->jitcode);
 
     // All done.
     return info;
 }
 
 static bool
-DoUseCountFallback(JSContext *cx, ICUseCount_Fallback *stub, BaselineFrame *frame,
+DoWarmUpCounterFallback(JSContext *cx, ICWarmUpCounter_Fallback *stub, BaselineFrame *frame,
                    IonOsrTempData **infoPtr)
 {
     JS_ASSERT(infoPtr);
     *infoPtr = nullptr;
 
     // A TI OOM will disable TI and Ion.
     if (!jit::IsIonEnabled(cx))
         return true;
 
     RootedScript script(cx, frame->script());
     jsbytecode *pc = stub->icEntry()->pc(script);
     bool isLoopEntry = JSOp(*pc) == JSOP_LOOPENTRY;
 
     JS_ASSERT(!isLoopEntry || LoopEntryCanIonOsr(pc));
 
-    FallbackICSpew(cx, stub, "UseCount(%d)", isLoopEntry ? int(script->pcToOffset(pc)) : int(-1));
+    FallbackICSpew(cx, stub, "WarmUpCounter(%d)", isLoopEntry ? int(script->pcToOffset(pc)) : int(-1));
 
     if (!script->canIonCompile()) {
         // TODO: ASSERT that ion-compilation-disabled checker stub doesn't exist.
         // TODO: Clear all optimized stubs.
         // TODO: Add a ion-compilation-disabled checker IC stub
-        script->resetUseCount();
+        script->resetWarmUpCounter();
         return true;
     }
 
     JS_ASSERT(!script->isIonCompilingOffThread());
 
     // If Ion script exists, but PC is not at a loop entry, then Ion will be entered for
     // this script at an appropriate LOOPENTRY or the next time this function is called.
     if (script->hasIonScript() && !isLoopEntry) {
@@ -955,18 +955,18 @@ DoUseCountFallback(JSContext *cx, ICUseC
         // TODO: ASSERT that a ion-script-already-exists checker stub doesn't exist.
         // TODO: Clear all optimized stubs.
         // TODO: Add a ion-script-already-exists checker stub.
         return true;
     }
 
     // Ensure that Ion-compiled code is available.
     JitSpew(JitSpew_BaselineOSR,
-            "UseCount for %s:%d reached %d at pc %p, trying to switch to Ion!",
-            script->filename(), script->lineno(), (int) script->getUseCount(), (void *) pc);
+            "WarmUpCounter for %s:%d reached %d at pc %p, trying to switch to Ion!",
+            script->filename(), script->lineno(), (int) script->getWarmUpCounter(), (void *) pc);
     void *jitcode = nullptr;
     if (!EnsureCanEnterIon(cx, stub, frame, script, pc, &jitcode))
         return false;
 
     // Jitcode should only be set here if not at loop entry.
     JS_ASSERT_IF(!isLoopEntry, !jitcode);
     if (!jitcode)
         return true;
@@ -976,46 +976,46 @@ DoUseCountFallback(JSContext *cx, ICUseC
     IonOsrTempData *info = PrepareOsrTempData(cx, stub, frame, script, pc, jitcode);
     if (!info)
         return false;
     *infoPtr = info;
 
     return true;
 }
 
-typedef bool (*DoUseCountFallbackFn)(JSContext *, ICUseCount_Fallback *, BaselineFrame *frame,
+typedef bool (*DoWarmUpCounterFallbackFn)(JSContext *, ICWarmUpCounter_Fallback *, BaselineFrame *frame,
                                      IonOsrTempData **infoPtr);
-static const VMFunction DoUseCountFallbackInfo =
-    FunctionInfo<DoUseCountFallbackFn>(DoUseCountFallback);
-
-bool
-ICUseCount_Fallback::Compiler::generateStubCode(MacroAssembler &masm)
+static const VMFunction DoWarmUpCounterFallbackInfo =
+    FunctionInfo<DoWarmUpCounterFallbackFn>(DoWarmUpCounterFallback);
+
+bool
+ICWarmUpCounter_Fallback::Compiler::generateStubCode(MacroAssembler &masm)
 {
     // enterStubFrame is going to clobber the BaselineFrameReg, save it in R0.scratchReg()
     // first.
     masm.movePtr(BaselineFrameReg, R0.scratchReg());
 
     // Push a stub frame so that we can perform a non-tail call.
     enterStubFrame(masm, R1.scratchReg());
 
     Label noCompiledCode;
-    // Call DoUseCountFallback to compile/check-for Ion-compiled function
+    // Call DoWarmUpCounterFallback to compile/check-for Ion-compiled function
     {
         // Push IonOsrTempData pointer storage
         masm.subPtr(Imm32(sizeof(void *)), BaselineStackReg);
         masm.push(BaselineStackReg);
 
         // Push IonJSFrameLayout pointer.
         masm.loadBaselineFramePtr(R0.scratchReg(), R0.scratchReg());
         masm.push(R0.scratchReg());
 
         // Push stub pointer.
         masm.push(BaselineStubReg);
 
-        if (!callVM(DoUseCountFallbackInfo, masm))
+        if (!callVM(DoWarmUpCounterFallbackInfo, masm))
             return false;
 
         // Pop IonOsrTempData pointer.
         masm.pop(R0.scratchReg());
 
         leaveStubFrame(masm);
 
         // If no JitCode was found, then skip just exit the IC.
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -23,17 +23,17 @@ namespace jit {
 //
 // Baseline Inline Caches are polymorphic caches that aggressively
 // share their stub code.
 //
 // Every polymorphic site contains a linked list of stubs which are
 // specific to that site.  These stubs are composed of a |StubData|
 // structure that stores parametrization information (e.g.
 // the shape pointer for a shape-check-and-property-get stub), any
-// dynamic information (e.g. use counts), a pointer to the stub code,
+// dynamic information (e.g. warm-up counters), a pointer to the stub code,
 // and a pointer to the next stub state in the linked list.
 //
 // Every BaselineScript keeps an table of |CacheDescriptor| data
 // structures, which store the following:
 //      A pointer to the first StubData in the cache.
 //      The bytecode PC of the relevant IC.
 //      The machine-code PC where the call to the stubcode returns.
 //
@@ -311,17 +311,17 @@ class ICEntry
 
     inline ICStub **addressOfFirstStub() {
         return &firstStub_;
     }
 };
 
 // List of baseline IC stub kinds.
 #define IC_STUB_KIND_LIST(_)    \
-    _(UseCount_Fallback)        \
+    _(WarmUpCounter_Fallback)   \
                                 \
     _(Profiler_Fallback)        \
     _(Profiler_PushFunction)    \
                                 \
     _(TypeMonitor_Fallback)     \
     _(TypeMonitor_SingleObject) \
     _(TypeMonitor_TypeObject)   \
     _(TypeMonitor_PrimitiveSet) \
@@ -785,17 +785,17 @@ class ICStub
         switch (kind) {
           case Call_Fallback:
           case Call_Scripted:
           case Call_AnyScripted:
           case Call_Native:
           case Call_ScriptedApplyArray:
           case Call_ScriptedApplyArguments:
           case Call_ScriptedFunCall:
-          case UseCount_Fallback:
+          case WarmUpCounter_Fallback:
           case GetElem_NativeSlot:
           case GetElem_NativePrototypeSlot:
           case GetElem_NativePrototypeCallNative:
           case GetElem_NativePrototypeCallScripted:
           case GetProp_CallScripted:
           case GetProp_CallNative:
           case GetProp_CallNativePrototype:
           case GetProp_CallDOMProxyNative:
@@ -1169,46 +1169,46 @@ class ICMultiStubCompiler : public ICStu
     virtual int32_t getKey() const {
         return static_cast<int32_t>(kind) | (static_cast<int32_t>(op) << 16);
     }
 
     ICMultiStubCompiler(JSContext *cx, ICStub::Kind kind, JSOp op)
       : ICStubCompiler(cx, kind), op(op) {}
 };
 
-// UseCount_Fallback
-
-// A UseCount IC chain has only the fallback stub.
-class ICUseCount_Fallback : public ICFallbackStub
+// WarmUpCounter_Fallback
+
+// A WarmUpCounter IC chain has only the fallback stub.
+class ICWarmUpCounter_Fallback : public ICFallbackStub
 {
     friend class ICStubSpace;
 
-    explicit ICUseCount_Fallback(JitCode *stubCode)
-      : ICFallbackStub(ICStub::UseCount_Fallback, stubCode)
+    explicit ICWarmUpCounter_Fallback(JitCode *stubCode)
+      : ICFallbackStub(ICStub::WarmUpCounter_Fallback, stubCode)
     { }
 
   public:
-    static inline ICUseCount_Fallback *New(ICStubSpace *space, JitCode *code) {
+    static inline ICWarmUpCounter_Fallback *New(ICStubSpace *space, JitCode *code) {
         if (!code)
             return nullptr;
-        return space->allocate<ICUseCount_Fallback>(code);
+        return space->allocate<ICWarmUpCounter_Fallback>(code);
     }
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         bool generateStubCode(MacroAssembler &masm);
 
       public:
         explicit Compiler(JSContext *cx)
-          : ICStubCompiler(cx, ICStub::UseCount_Fallback)
+          : ICStubCompiler(cx, ICStub::WarmUpCounter_Fallback)
         { }
 
-        ICUseCount_Fallback *getStub(ICStubSpace *space) {
-            return ICUseCount_Fallback::New(space, getStubCode());
+        ICWarmUpCounter_Fallback *getStub(ICStubSpace *space) {
+            return ICWarmUpCounter_Fallback::New(space, getStubCode());
         }
     };
 };
 
 // Profiler_Fallback
 
 class ICProfiler_Fallback : public ICFallbackStub
 {
--- a/js/src/jit/BaselineJIT.cpp
+++ b/js/src/jit/BaselineJIT.cpp
@@ -253,27 +253,27 @@ CanEnterBaselineJIT(JSContext *cx, Handl
         return Method_CantCompile;
 
     if (!cx->compartment()->ensureJitCompartmentExists(cx))
         return Method_Error;
 
     if (script->hasBaselineScript())
         return Method_Compiled;
 
-    // Check script use count.
+    // Check script warm-up counter.
     //
     // Also eagerly compile if we are in parallel warmup, the point of which
     // is to gather type information so that the script may be compiled for
     // parallel execution. We want to avoid the situation of OSRing during
-    // warmup and only gathering type information for the loop, and not the
+    // warm-up and only gathering type information for the loop, and not the
     // rest of the function.
     if (cx->runtime()->forkJoinWarmup > 0) {
         if (osr)
             return Method_Skipped;
-    } else if (script->incUseCount() <= js_JitOptions.baselineUsesBeforeCompile) {
+    } else if (script->incWarmUpCounter() <= js_JitOptions.baselineUsesBeforeCompile) {
         return Method_Skipped;
     }
 
     if (script->isCallsiteClone()) {
         // Ensure the original function is compiled too, so that bailouts from
         // Ion code have a BaselineScript to resume into.
         RootedScript original(cx, script->donorFunction()->nonLazyScript());
         JS_ASSERT(original != script);
--- a/js/src/jit/BytecodeAnalysis.cpp
+++ b/js/src/jit/BytecodeAnalysis.cpp
@@ -66,17 +66,17 @@ BytecodeAnalysis::init(TempAllocator &al
 
 
         unsigned stackDepth = infos_[offset].stackDepth;
 #ifdef DEBUG
         for (jsbytecode *chkpc = pc + 1; chkpc < (pc + GetBytecodeLength(pc)); chkpc++)
             JS_ASSERT(!infos_[script_->pcToOffset(chkpc)].initialized);
 #endif
 
-        unsigned nuses = GetUseCount(script_, offset);
+        unsigned nuses = GetWarmUpCounter(script_, offset);
         unsigned ndefs = GetDefCount(script_, offset);
 
         JS_ASSERT(stackDepth >= nuses);
         stackDepth -= nuses;
         stackDepth += ndefs;
 
         // If stack depth exceeds max allowed by analysis, fail fast.
         JS_ASSERT(stackDepth <= BytecodeInfo::MAX_STACK_DEPTH);
--- a/js/src/jit/C1Spewer.cpp
+++ b/js/src/jit/C1Spewer.cpp
@@ -88,17 +88,17 @@ C1Spewer::finish()
     if (spewout_)
         fclose(spewout_);
 }
 
 static void
 DumpDefinition(FILE *fp, MDefinition *def)
 {
     fprintf(fp, "      ");
-    fprintf(fp, "%u %u ", def->id(), unsigned(def->useCount()));
+    fprintf(fp, "%u %u ", def->id(), unsigned(def->warmUpCounter()));
     def->printName(fp);
     fprintf(fp, " ");
     def->printOpcode(fp);
     fprintf(fp, " <|@\n");
 }
 
 static void
 DumpLIR(FILE *fp, LInstruction *ins)
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -9101,18 +9101,18 @@ static const VMFunction RecompileFnInfo 
 
 bool
 CodeGenerator::visitRecompileCheck(LRecompileCheck *ins)
 {
     Label done;
     Register tmp = ToRegister(ins->scratch());
     OutOfLineCode *ool = oolCallVM(RecompileFnInfo, ins, (ArgList()), StoreRegisterTo(tmp));
 
-    // Check if usecount is high enough.
-    masm.movePtr(ImmPtr(ins->mir()->script()->addressOfUseCount()), tmp);
+    // Check if warm-up counter is high enough.
+    masm.movePtr(ImmPtr(ins->mir()->script()->addressOfWarmUpCounter()), tmp);
     Address ptr(tmp, 0);
     masm.add32(Imm32(1), tmp);
     masm.branch32(Assembler::BelowOrEqual, ptr, Imm32(ins->mir()->recompileThreshold()), &done);
 
     // Check if not yet recompiling.
     CodeOffsetLabel label = masm.movWithPatch(ImmWord(uintptr_t(-1)), tmp);
     if (!ionScriptLabels_.append(label))
         return false;
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -2769,24 +2769,24 @@ jit::Invalidate(types::TypeZone &types, 
         co.invalidate();
         numInvalidations--;
 
         // Wait for the scripts to get warm again before doing another
         // compile, unless either:
         // (1) we are recompiling *because* a script got hot;
         //     (resetUses is false); or,
         // (2) we are invalidating a parallel script.  This is because
-        //     the useCount only applies to sequential uses.  Parallel
+        //     the warmUpCounter only applies to sequential uses.  Parallel
         //     execution *requires* ion, and so we don't limit it to
         //     methods with a high usage count (though we do check that
-        //     the useCount is at least 1 when compiling the transitive
+        //     the warmUpCounter is at least 1 when compiling the transitive
         //     closure of potential callees, to avoid compiling things
         //     that are never run at all).
         if (resetUses && executionMode != ParallelExecution)
-            script->resetUseCount();
+            script->resetWarmUpCounter();
     }
 
     // Make sure we didn't leak references by invalidating the same IonScript
     // multiple times in the above loop.
     JS_ASSERT(!numInvalidations);
 }
 
 void
@@ -3208,17 +3208,17 @@ AutoDebugModeInvalidation::~AutoDebugMod
     }
 
     for (gc::ZoneCellIter i(zone, gc::FINALIZE_SCRIPT); !i.done(); i.next()) {
         JSScript *script = i.get<JSScript>();
         if (script->compartment() == comp_ || zone_) {
             FinishInvalidation<SequentialExecution>(fop, script);
             FinishInvalidation<ParallelExecution>(fop, script);
             FinishDiscardBaselineScript(fop, script);
-            script->resetUseCount();
+            script->resetWarmUpCounter();
         } else if (script->hasBaselineScript()) {
             script->baselineScript()->resetActive();
         }
     }
 }
 
 bool
 jit::JitSupportsFloatingPoint()
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -651,23 +651,23 @@ IonBuilder::build()
         return false;
 
 #ifdef DEBUG
     if (info().executionModeIsAnalysis()) {
         JitSpew(JitSpew_Scripts, "Analyzing script %s:%d (%p) %s",
                 script()->filename(), script()->lineno(), (void *)script(),
                 ExecutionModeString(info().executionMode()));
     } else if (info().executionMode() == SequentialExecution && script()->hasIonScript()) {
-        JitSpew(JitSpew_Scripts, "Recompiling script %s:%d (%p) (usecount=%d, level=%s)",
+        JitSpew(JitSpew_Scripts, "Recompiling script %s:%d (%p) (warmup-counter=%d, level=%s)",
                 script()->filename(), script()->lineno(), (void *)script(),
-                (int)script()->getUseCount(), OptimizationLevelString(optimizationInfo().level()));
+                (int)script()->getWarmUpCounter(), OptimizationLevelString(optimizationInfo().level()));
     } else {
-        JitSpew(JitSpew_Scripts, "Compiling script %s:%d (%p) (usecount=%d, level=%s)",
+        JitSpew(JitSpew_Scripts, "Compiling script %s:%d (%p) (warmup-counter=%d, level=%s)",
                 script()->filename(), script()->lineno(), (void *)script(),
-                (int)script()->getUseCount(), OptimizationLevelString(optimizationInfo().level()));
+                (int)script()->getWarmUpCounter(), OptimizationLevelString(optimizationInfo().level()));
     }
 #endif
 
     initParameters();
 
     // Initialize local variables.
     for (uint32_t i = 0; i < info().nlocals(); i++) {
         MConstant *undef = MConstant::New(alloc(), UndefinedValue());
@@ -1272,21 +1272,21 @@ IonBuilder::traverseBytecode()
         //   (1) Have the ImplicitlyUsed flag set on them.
         //   (2) Have more uses than before compiling this op (the value is
         //       used as operand of a new MIR instruction).
         //
         // This is used to catch problems where IonBuilder pops a value without
         // adding any SSA uses and doesn't call setImplicitlyUsedUnchecked on it.
         Vector<MDefinition *, 4, IonAllocPolicy> popped(alloc());
         Vector<size_t, 4, IonAllocPolicy> poppedUses(alloc());
-        unsigned nuses = GetUseCount(script_, script_->pcToOffset(pc));
+        unsigned nuses = GetWarmUpCounter(script_, script_->pcToOffset(pc));
 
         for (unsigned i = 0; i < nuses; i++) {
             MDefinition *def = current->peek(-int32_t(i + 1));
-            if (!popped.append(def) || !poppedUses.append(def->defUseCount()))
+            if (!popped.append(def) || !poppedUses.append(def->defWarmUpCounter()))
                 return false;
         }
 #endif
 
         // Nothing in inspectOpcode() is allowed to advance the pc.
         JSOp op = JSOp(*pc);
         if (!inspectOpcode(op))
             return false;
@@ -1323,17 +1323,17 @@ IonBuilder::traverseBytecode()
                 JS_ASSERT(popped[i]->isImplicitlyUsed() ||
 
                           // MNewDerivedTypedObject instances are
                           // often dead unless they escape from the
                           // fn. See IonBuilder::loadTypedObjectData()
                           // for more details.
                           popped[i]->isNewDerivedTypedObject() ||
 
-                          popped[i]->defUseCount() > poppedUses[i]);
+                          popped[i]->defWarmUpCounter() > poppedUses[i]);
                 break;
             }
         }
 #endif
 
         pc += js_CodeSpec[op].length;
         current->updateTrackedSite(bytecodeSite(pc));
     }
@@ -4362,17 +4362,17 @@ IonBuilder::makeInliningDecision(JSFunct
         // Callee must not be excessively large.
         // This heuristic also applies to the callsite as a whole.
         if (targetScript->length() > optimizationInfo().inlineMaxTotalBytecodeLength())
             return DontInline(targetScript, "Vetoed: callee excessively large");
 
         // Callee must have been called a few times to have somewhat stable
         // type information, except for definite properties analysis,
         // as the caller has not run yet.
-        if (targetScript->getUseCount() < optimizationInfo().usesBeforeInlining() &&
+        if (targetScript->getWarmUpCounter() < optimizationInfo().usesBeforeInlining() &&
             !targetScript->baselineScript()->ionCompiledOrInlined() &&
             info().executionMode() != DefinitePropertiesAnalysis)
         {
             return DontInline(targetScript, "Vetoed: callee is insufficiently hot.");
         }
     }
 
     // TI calls ObjectStateChange to trigger invalidation of the caller.
@@ -6371,27 +6371,27 @@ IonBuilder::insertRecompileCheck()
     // No need for recompile checks if this is the highest optimization level.
     OptimizationLevel curLevel = optimizationInfo().level();
     if (js_IonOptimizations.isLastLevel(curLevel))
         return;
 
     // Add recompile check.
 
     // Get the topmost builder. The topmost script will get recompiled when
-    // usecount is high enough to justify a higher optimization level.
+    // warm-up counter is high enough to justify a higher optimization level.
     IonBuilder *topBuilder = this;
     while (topBuilder->callerBuilder_)
         topBuilder = topBuilder->callerBuilder_;
 
-    // Add recompile check to recompile when the usecount reaches the usecount
-    // of the next optimization level.
+    // Add recompile check to recompile when the warm-up counter reaches the
+    // threshold of the next optimization level.
     OptimizationLevel nextLevel = js_IonOptimizations.nextLevel(curLevel);
     const OptimizationInfo *info = js_IonOptimizations.get(nextLevel);
-    uint32_t useCount = info->usesBeforeCompile(topBuilder->script());
-    current->add(MRecompileCheck::New(alloc(), topBuilder->script(), useCount));
+    uint32_t warmUpCounter = info->usesBeforeCompile(topBuilder->script());
+    current->add(MRecompileCheck::New(alloc(), topBuilder->script(), warmUpCounter));
 }
 
 JSObject *
 IonBuilder::testSingletonProperty(JSObject *obj, PropertyName *name)
 {
     // We would like to completely no-op property/global accesses which can
     // produce only a particular JSObject. When indicating the access result is
     // definitely an object, type inference does not account for the
--- a/js/src/jit/IonFrames.cpp
+++ b/js/src/jit/IonFrames.cpp
@@ -445,19 +445,19 @@ HandleExceptionIon(JSContext *cx, const 
           }
 
           case JSTRY_LOOP:
             break;
 
           case JSTRY_CATCH:
             if (cx->isExceptionPending() && !bailedOutForDebugMode) {
                 // Ion can compile try-catch, but bailing out to catch
-                // exceptions is slow. Reset the use count so that if we
+                // exceptions is slow. Reset the warm-up counter so that if we
                 // catch many exceptions we won't Ion-compile the script.
-                script->resetUseCount();
+                script->resetWarmUpCounter();
 
                 // Bailout at the start of the catch block.
                 jsbytecode *catchPC = script->main() + tn->start + tn->length;
                 ExceptionBailoutInfo excInfo(frame.frameNo(), catchPC, tn->stackDepth);
                 uint32_t retval = ExceptionHandlerBailout(cx, frame, rfe, excInfo, overrecursed);
                 if (retval == BAILOUT_RETURN_OK)
                     return;
 
@@ -563,19 +563,19 @@ HandleExceptionBaseline(JSContext *cx, c
         rfe->framePointer = frame.fp() - BaselineFrame::FramePointerOffset;
         rfe->stackPointer = rfe->framePointer - BaselineFrame::Size() -
             (script->nfixed() + tn->stackDepth) * sizeof(Value);
 
         switch (tn->kind) {
           case JSTRY_CATCH:
             if (cx->isExceptionPending()) {
                 // Ion can compile try-catch, but bailing out to catch
-                // exceptions is slow. Reset the use count so that if we
+                // exceptions is slow. Reset the warm-up counter so that if we
                 // catch many exceptions we won't Ion-compile the script.
-                script->resetUseCount();
+                script->resetWarmUpCounter();
 
                 // Resume at the start of the catch block.
                 rfe->kind = ResumeFromException::RESUME_CATCH;
                 jsbytecode *catchPC = script->main() + tn->start + tn->length;
                 rfe->target = script->baselineScript()->nativeCodeForPC(script, catchPC);
                 return;
             }
             break;
--- a/js/src/jit/IonOptimizationLevels.cpp
+++ b/js/src/jit/IonOptimizationLevels.cpp
@@ -70,19 +70,19 @@ OptimizationInfo::usesBeforeCompile(JSSc
     if (pc == script->code())
         pc = nullptr;
 
     uint32_t minUses = usesBeforeCompile_;
     if (js_JitOptions.forceDefaultIonUsesBeforeCompile)
         minUses = js_JitOptions.forcedDefaultIonUsesBeforeCompile;
 
     // If the script is too large to compile on the main thread, we can still
-    // compile it off thread. In these cases, increase the use count threshold
-    // to improve the compilation's type information and hopefully avoid later
-    // recompilation.
+    // compile it off thread. In these cases, increase the warm-up counter
+    // threshold to improve the compilation's type information and hopefully
+    // avoid later recompilation.
 
     if (script->length() > MAX_MAIN_THREAD_SCRIPT_SIZE)
         minUses = minUses * (script->length() / (double) MAX_MAIN_THREAD_SCRIPT_SIZE);
 
     uint32_t numLocalsAndArgs = NumLocalsAndArgs(script);
     if (numLocalsAndArgs > MAX_MAIN_THREAD_LOCALS_AND_ARGS)
         minUses = minUses * (numLocalsAndArgs / (double) MAX_MAIN_THREAD_LOCALS_AND_ARGS);
 
@@ -139,17 +139,17 @@ OptimizationInfos::isLastLevel(Optimizat
 OptimizationLevel
 OptimizationInfos::levelForScript(JSScript *script, jsbytecode *pc) const
 {
     OptimizationLevel prev = Optimization_DontCompile;
 
     while (!isLastLevel(prev)) {
         OptimizationLevel level = nextLevel(prev);
         const OptimizationInfo *info = get(level);
-        if (script->getUseCount() < info->usesBeforeCompile(script, pc))
+        if (script->getWarmUpCounter() < info->usesBeforeCompile(script, pc))
             return prev;
 
         prev = level;
     }
 
     return prev;
 }
 
--- a/js/src/jit/JitOptions.cpp
+++ b/js/src/jit/JitOptions.cpp
@@ -124,23 +124,23 @@ JitOptions::setEagerCompilation()
 {
     eagerCompilation = true;
     baselineUsesBeforeCompile = 0;
     forceDefaultIonUsesBeforeCompile = true;
     forcedDefaultIonUsesBeforeCompile = 0;
 }
 
 void
-JitOptions::setUsesBeforeCompile(uint32_t useCount)
+JitOptions::setUsesBeforeCompile(uint32_t warmUpCounter)
 {
     forceDefaultIonUsesBeforeCompile = true;
-    forcedDefaultIonUsesBeforeCompile = useCount;
+    forcedDefaultIonUsesBeforeCompile = warmUpCounter;
 
     // Undo eager compilation
-    if (eagerCompilation && useCount != 0) {
+    if (eagerCompilation && warmUpCounter != 0) {
         jit::JitOptions defaultValues;
         eagerCompilation = false;
         baselineUsesBeforeCompile = defaultValues.baselineUsesBeforeCompile;
     }
 }
 
 void
 JitOptions::resetUsesBeforeCompile()
--- a/js/src/jit/JitOptions.h
+++ b/js/src/jit/JitOptions.h
@@ -55,17 +55,17 @@ struct JitOptions
     uint32_t maxStackArgs;
     uint32_t osrPcMismatchesBeforeRecompile;
     uint32_t smallFunctionMaxBytecodeLength_;
     uint32_t usesBeforeCompilePar;
 
     JitOptions();
     bool isSmallFunction(JSScript *script) const;
     void setEagerCompilation();
-    void setUsesBeforeCompile(uint32_t useCount);
+    void setUsesBeforeCompile(uint32_t warmUpCounter);
     void resetUsesBeforeCompile();
 };
 
 extern JitOptions js_JitOptions;
 
 } // namespace jit
 } // namespace js
 
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -382,26 +382,26 @@ MDefinition::dumpLocation(FILE *fp) cons
 void
 MDefinition::dumpLocation() const
 {
     dumpLocation(stderr);
 }
 
 #ifdef DEBUG
 size_t
-MDefinition::useCount() const
+MDefinition::warmUpCounter() const
 {
     size_t count = 0;
     for (MUseIterator i(uses_.begin()); i != uses_.end(); i++)
         count++;
     return count;
 }
 
 size_t
-MDefinition::defUseCount() const
+MDefinition::defWarmUpCounter() const
 {
     size_t count = 0;
     for (MUseIterator i(uses_.begin()); i != uses_.end(); i++)
         if ((*i)->consumer()->isDefinition())
             count++;
     return count;
 }
 #endif
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -626,23 +626,23 @@ class MDefinition : public MNode
     void removeUse(MUse *use) {
         uses_.remove(use);
     }
 
 #ifdef DEBUG
     // Number of uses of this instruction. This function is only available
     // in DEBUG mode since it requires traversing the list. Most users should
     // use hasUses() or hasOneUse() instead.
-    size_t useCount() const;
+    size_t warmUpCounter() const;
 
     // Number of uses of this instruction (only counting MDefinitions, ignoring
     // MResumePoints). This function is only available in DEBUG mode since it
     // requires traversing the list. Most users should use hasUses() or
     // hasOneUse() instead.
-    size_t defUseCount() const;
+    size_t defWarmUpCounter() const;
 #endif
 
     // Test whether this MDefinition has exactly one use.
     bool hasOneUse() const;
 
     // Test whether this MDefinition has exactly one use.
     // (only counting MDefinitions, ignoring MResumePoints)
     bool hasOneDefUse() const;
@@ -11298,36 +11298,36 @@ class MHasClass
         if (!ins->isHasClass())
             return false;
         if (getClass() != ins->toHasClass()->getClass())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 };
 
-// Increase the usecount of the provided script upon execution and test if
-// the usecount surpasses the threshold. Upon hit it will recompile the
+// Increase the warm-up counter of the provided script upon execution and test if
+// the warm-up counter surpasses the threshold. Upon hit it will recompile the
 // outermost script (i.e. not the inlined script).
 class MRecompileCheck : public MNullaryInstruction
 {
     JSScript *script_;
     uint32_t recompileThreshold_;
 
     MRecompileCheck(JSScript *script, uint32_t recompileThreshold)
       : script_(script),
         recompileThreshold_(recompileThreshold)
     {
         setGuard();
     }
 
   public:
     INSTRUCTION_HEADER(RecompileCheck);
 
-    static MRecompileCheck *New(TempAllocator &alloc, JSScript *script_, uint32_t useCount) {
-        return new(alloc) MRecompileCheck(script_, useCount);
+    static MRecompileCheck *New(TempAllocator &alloc, JSScript *script_, uint32_t warmUpCounter) {
+        return new(alloc) MRecompileCheck(script_, warmUpCounter);
     }
 
     JSScript *script() const {
         return script_;
     }
 
     uint32_t recompileThreshold() const {
         return recompileThreshold_;
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -6192,24 +6192,24 @@ JS_SetOffthreadIonCompilationEnabled(JSR
 {
     rt->setOffthreadIonCompilationEnabled(enabled);
 }
 
 JS_PUBLIC_API(void)
 JS_SetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt, uint32_t value)
 {
     switch (opt) {
-      case JSJITCOMPILER_BASELINE_USECOUNT_TRIGGER:
+      case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER:
         if (value == uint32_t(-1)) {
             jit::JitOptions defaultValues;
             value = defaultValues.baselineUsesBeforeCompile;
         }
         jit::js_JitOptions.baselineUsesBeforeCompile = value;
         break;
-      case JSJITCOMPILER_ION_USECOUNT_TRIGGER:
+      case JSJITCOMPILER_ION_WARMUP_TRIGGER:
         if (value == uint32_t(-1)) {
             jit::js_JitOptions.resetUsesBeforeCompile();
             break;
         }
         jit::js_JitOptions.setUsesBeforeCompile(value);
         if (value == 0)
             jit::js_JitOptions.setEagerCompilation();
         break;
@@ -6254,19 +6254,19 @@ JS_SetGlobalJitCompilerOption(JSRuntime 
     }
 }
 
 JS_PUBLIC_API(int)
 JS_GetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt)
 {
 #ifndef JS_CODEGEN_NONE
     switch (opt) {
-      case JSJITCOMPILER_BASELINE_USECOUNT_TRIGGER:
+      case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER:
         return jit::js_JitOptions.baselineUsesBeforeCompile;
-      case JSJITCOMPILER_ION_USECOUNT_TRIGGER:
+      case JSJITCOMPILER_ION_WARMUP_TRIGGER:
         return jit::js_JitOptions.forcedDefaultIonUsesBeforeCompile;
       case JSJITCOMPILER_ION_ENABLE:
         return JS::RuntimeOptionsRef(rt).ion();
       case JSJITCOMPILER_BASELINE_ENABLE:
         return JS::RuntimeOptionsRef(rt).baseline();
       case JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE:
         return rt->canUseOffthreadIonCompilation();
       case JSJITCOMPILER_SIGNALS_ENABLE:
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -4887,18 +4887,18 @@ JS_ScheduleGC(JSContext *cx, uint32_t co
 
 extern JS_PUBLIC_API(void)
 JS_SetParallelParsingEnabled(JSRuntime *rt, bool enabled);
 
 extern JS_PUBLIC_API(void)
 JS_SetOffthreadIonCompilationEnabled(JSRuntime *rt, bool enabled);
 
 #define JIT_COMPILER_OPTIONS(Register)                                  \
-    Register(BASELINE_USECOUNT_TRIGGER, "baseline.usecount.trigger")    \
-    Register(ION_USECOUNT_TRIGGER, "ion.usecount.trigger")              \
+    Register(BASELINE_WARMUP_TRIGGER, "baseline.warmup.trigger")    \
+    Register(ION_WARMUP_TRIGGER, "ion.warmup.trigger")              \
     Register(ION_ENABLE, "ion.enable")                                  \
     Register(BASELINE_ENABLE, "baseline.enable")                        \
     Register(OFFTHREAD_COMPILATION_ENABLE, "offthread-compilation.enable") \
     Register(SIGNALS_ENABLE, "signals.enable")
 
 typedef enum JSJitCompilerOption {
 #define JIT_COMPILER_DECLARE(key, str) \
     JSJITCOMPILER_ ## key,
--- a/js/src/jscompartment.cpp
+++ b/js/src/jscompartment.cpp
@@ -606,17 +606,17 @@ JSCompartment::sweep(FreeOp *fop, bool r
     {
         selfHostingScriptSource.set(nullptr);
     }
 
     if (jitCompartment_)
         jitCompartment_->sweep(fop, this);
 
     /*
-     * JIT code increments activeUseCount for any RegExpShared used by jit
+     * JIT code increments activeWarmUpCounter for any RegExpShared used by jit
      * code for the lifetime of the JIT script. Thus, we must perform
      * sweeping after clearing jit code.
      */
     regExps.sweep(rt);
 
     if (debugScopes)
         debugScopes->sweep(rt);
 
--- a/js/src/jsinfer.cpp
+++ b/js/src/jsinfer.cpp
@@ -1245,17 +1245,17 @@ types::FinishCompilation(JSContext *cx, 
         for (size_t i = 0; i < count; i++) {
             if (!array[i].addConstraint(cx, cx->typeLifoAlloc().new_<TypeConstraintFreezeStack>(entry.script), false))
                 succeeded = false;
         }
     }
 
     if (!succeeded || types.compilerOutputs->back().pendingInvalidation()) {
         types.compilerOutputs->back().invalidate();
-        script->resetUseCount();
+        script->resetWarmUpCounter();
         return false;
     }
 
     return true;
 }
 
 static void
 CheckDefinitePropertiesTypeSet(JSContext *cx, TemporaryTypeSet *frozen, StackTypeSet *actual)
@@ -2413,17 +2413,17 @@ void
 TypeZone::addPendingRecompile(JSContext *cx, JSScript *script)
 {
     JS_ASSERT(script);
 
     CancelOffThreadIonCompile(cx->compartment(), script);
 
     // Let the script warm up again before attempting another compile.
     if (jit::IsBaselineEnabled(cx))
-        script->resetUseCount();
+        script->resetWarmUpCounter();
 
     if (script->hasIonScript())
         addPendingRecompile(cx, script->ionScript()->recompileInfo());
 
     if (script->hasParallelIonScript())
         addPendingRecompile(cx, script->parallelIonScript()->recompileInfo());
 
     // When one script is inlined into another the caller listens to state
--- a/js/src/jsopcode.cpp
+++ b/js/src/jsopcode.cpp
@@ -409,17 +409,17 @@ class BytecodeParser
                         uint32_t stackDepth, const uint32_t *offsetStack);
 };
 
 }  // anonymous namespace
 
 uint32_t
 BytecodeParser::simulateOp(JSOp op, uint32_t offset, uint32_t *offsetStack, uint32_t stackDepth)
 {
-    uint32_t nuses = GetUseCount(script_, offset);
+    uint32_t nuses = GetWarmUpCounter(script_, offset);
     uint32_t ndefs = GetDefCount(script_, offset);
 
     JS_ASSERT(stackDepth >= nuses);
     stackDepth -= nuses;
     JS_ASSERT(stackDepth + ndefs <= maximumStackDepth());
 
     // Mark the current offset as defining its values on the offset stack,
     // unless it just reshuffles the stack.  In that case we want to preserve
--- a/js/src/jsopcodeinlines.h
+++ b/js/src/jsopcodeinlines.h
@@ -35,17 +35,17 @@ GetDefCount(JSScript *script, unsigned o
          */
         return pc[1] + 1;
       default:
         return StackDefs(script, pc);
     }
 }
 
 static inline unsigned
-GetUseCount(JSScript *script, unsigned offset)
+GetWarmUpCounter(JSScript *script, unsigned offset)
 {
     jsbytecode *pc = script->offsetToPC(offset);
 
     if (JSOp(*pc) == JSOP_PICK)
         return pc[1] + 1;
     if (js_CodeSpec[*pc].nuses == -1)
         return StackUses(script, pc);
     return js_CodeSpec[*pc].nuses;
--- a/js/src/jsscript.h
+++ b/js/src/jsscript.h
@@ -814,17 +814,17 @@ class JSScript : public js::gc::Barriere
 
     uint32_t        natoms_;    /* length of atoms array */
     uint32_t        nslots_;    /* vars plus maximum stack depth */
 
     /* Range of characters in scriptSource which contains this script's source. */
     uint32_t        sourceStart_;
     uint32_t        sourceEnd_;
 
-    uint32_t        useCount;   /* Number of times the script has been called
+    uint32_t        warmUpCounter;   /* Number of times the script has been called
                                  * or has had backedges taken. When running in
                                  * ion, also increased for any inlined scripts.
                                  * Reset if the script's JIT code is forcibly
                                  * discarded. */
 
 #ifdef DEBUG
     // Unique identifier within the compartment for this script, used for
     // printing analysis information.
@@ -1390,23 +1390,23 @@ class JSScript : public js::gc::Barriere
             return nullptr;
         return enclosingScopeOrOriginalFunction_;
     }
 
   private:
     bool makeTypes(JSContext *cx);
 
   public:
-    uint32_t getUseCount() const {
-        return useCount;
+    uint32_t getWarmUpCounter() const {
+        return warmUpCounter;
     }
-    uint32_t incUseCount(uint32_t amount = 1) { return useCount += amount; }
-    uint32_t *addressOfUseCount() { return &useCount; }
-    static size_t offsetOfUseCount() { return offsetof(JSScript, useCount); }
-    void resetUseCount() { useCount = 0; }
+    uint32_t incWarmUpCounter(uint32_t amount = 1) { return warmUpCounter += amount; }
+    uint32_t *addressOfWarmUpCounter() { return &warmUpCounter; }
+    static size_t offsetOfWarmUpCounter() { return offsetof(JSScript, warmUpCounter); }
+    void resetWarmUpCounter() { warmUpCounter = 0; }
 
   public:
     bool initScriptCounts(JSContext *cx);
     js::PCCounts getPCCounts(jsbytecode *pc);
     void addIonCounts(js::jit::IonScriptCounts *ionCounts);
     js::jit::IonScriptCounts *getIonCounts();
     js::ScriptCounts releaseScriptCounts();
     void destroyScriptCounts(js::FreeOp *fop);
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -5802,23 +5802,23 @@ SetRuntimeOptions(JSRuntime *rt, const O
         if (strcmp(str, "on") == 0)
             jit::js_JitOptions.limitScriptSize = true;
         else if (strcmp(str, "off") == 0)
             jit::js_JitOptions.limitScriptSize = false;
         else
             return OptionFailure("ion-limit-script-size", str);
     }
 
-    int32_t useCount = op.getIntOption("ion-uses-before-compile");
-    if (useCount >= 0)
-        jit::js_JitOptions.setUsesBeforeCompile(useCount);
-
-    useCount = op.getIntOption("baseline-uses-before-compile");
-    if (useCount >= 0)
-        jit::js_JitOptions.baselineUsesBeforeCompile = useCount;
+    int32_t warmUpCounter = op.getIntOption("ion-uses-before-compile");
+    if (warmUpCounter >= 0)
+        jit::js_JitOptions.setUsesBeforeCompile(warmUpCounter);
+
+    warmUpCounter = op.getIntOption("baseline-uses-before-compile");
+    if (warmUpCounter >= 0)
+        jit::js_JitOptions.baselineUsesBeforeCompile = warmUpCounter;
 
     if (op.getBoolOption("baseline-eager"))
         jit::js_JitOptions.baselineUsesBeforeCompile = 0;
 
     if (const char *str = op.getStringOption("ion-regalloc")) {
         if (strcmp(str, "lsra") == 0) {
             jit::js_JitOptions.forceRegisterAllocator = true;
             jit::js_JitOptions.forcedRegisterAllocator = jit::RegisterAllocator_LSRA;
--- a/js/src/vm/ForkJoin.cpp
+++ b/js/src/vm/ForkJoin.cpp
@@ -165,27 +165,27 @@ class ForkJoinOperation
         GreenLight
     };
 
     struct WorklistData {
         // True if we enqueued the callees from the ion-compiled
         // version of this entry
         bool calleesEnqueued;
 
-        // Last record useCount; updated after warmup
+        // Last record warmUpCounter; updated after warmup
         // iterations;
-        uint32_t useCount;
+        uint32_t warmUpCounter;
 
         // Number of continuous "stalls" --- meaning warmups
-        // where useCount did not increase.
+        // where warmUpCounter did not increase.
         uint32_t stallCount;
 
         void reset() {
             calleesEnqueued = false;
-            useCount = 0;
+            warmUpCounter = 0;
             stallCount = 0;
         }
     };
 
     JSContext *cx_;
     HandleFunction fun_;
     HandleObject updatable_;
     uint16_t sliceStart_;
@@ -644,42 +644,42 @@ ForkJoinOperation::compileForParallelExe
             script = worklist_[i];
             script->ensureNonLazyCanonicalFunction(cx_);
             fun = script->functionNonDelazifying();
 
             // No baseline script means no type information, hence we
             // will not be able to compile very well.  In such cases,
             // we continue to run baseline iterations until either (1)
             // the potential callee *has* a baseline script or (2) the
-            // potential callee's use count stops increasing,
+            // potential callee's warm-up counter stops increasing,
             // indicating that they are not in fact a callee.
             if (!script->hasBaselineScript()) {
-                uint32_t previousUseCount = worklistData_[i].useCount;
-                uint32_t currentUseCount = script->getUseCount();
-                if (previousUseCount < currentUseCount) {
-                    worklistData_[i].useCount = currentUseCount;
+                uint32_t previousWarmUpCounter = worklistData_[i].warmUpCounter;
+                uint32_t currentWarmUpCounter = script->getWarmUpCounter();
+                if (previousWarmUpCounter < currentWarmUpCounter) {
+                    worklistData_[i].warmUpCounter = currentWarmUpCounter;
                     worklistData_[i].stallCount = 0;
                     gatheringTypeInformation = true;
 
                     Spew(SpewCompile,
                          "Script %p:%s:%d has no baseline script, "
-                         "but use count grew from %d to %d",
+                         "but warm-up counter grew from %d to %d",
                          script.get(), script->filename(), script->lineno(),
-                         previousUseCount, currentUseCount);
+                         previousWarmUpCounter, currentWarmUpCounter);
                 } else {
                     uint32_t stallCount = ++worklistData_[i].stallCount;
                     if (stallCount < stallThreshold) {
                         gatheringTypeInformation = true;
                     }
 
                     Spew(SpewCompile,
                          "Script %p:%s:%d has no baseline script, "
-                         "and use count has %u stalls at %d",
+                         "and warm-up counter has %u stalls at %d",
                          script.get(), script->filename(), script->lineno(),
-                         stallCount, previousUseCount);
+                         stallCount, previousWarmUpCounter);
                 }
                 continue;
             }
 
             if (!script->hasParallelIonScript()) {
                 // Script has not yet been compiled. Attempt to compile it.
                 SpewBeginCompile(script);
                 MethodStatus mstatus = CanEnterInParallel(cx_, script);
@@ -732,24 +732,24 @@ ForkJoinOperation::compileForParallelExe
             // worklist if so. Clear the flag after that, since we
             // will be compiling the call targets.
             JS_ASSERT(script->hasParallelIonScript());
             if (appendCallTargetsToWorklist(i, status) == RedLight)
                 return RedLight;
         }
 
         // If there is compilation occurring in a helper thread, then
-        // run a warmup iterations in the main thread while we wait.
-        // There is a chance that this warmup will finish all the work
+        // run a warm-up iterations in the main thread while we wait.
+        // There is a chance that this warm-up will finish all the work
         // we have to do, so we should stop then, unless we are in
         // compile mode, in which case we'll continue to block.
         //
         // Note that even in compile mode, we can't block *forever*:
         // - OMTC compiles will finish;
-        // - no work is being done, so use counts on not-yet-baselined
+        // - no work is being done, so warm-up counters on not-yet-baselined
         //   scripts will not increase.
         if (offMainThreadCompilationsInProgress || gatheringTypeInformation) {
             bool stopIfComplete = (mode_ != ForkJoinModeCompile);
             if (warmupExecution(stopIfComplete, status) == RedLight)
                 return RedLight;
             continue;
         }
 
--- a/js/src/vm/HelperThreads.cpp
+++ b/js/src/vm/HelperThreads.cpp
@@ -554,19 +554,19 @@ IonBuilderHasHigherPriority(jit::IonBuil
     // A lower optimization level indicates a higher priority.
     if (first->optimizationInfo().level() != second->optimizationInfo().level())
         return first->optimizationInfo().level() < second->optimizationInfo().level();
 
     // A script without an IonScript has precedence on one with.
     if (first->script()->hasIonScript() != second->script()->hasIonScript())
         return !first->script()->hasIonScript();
 
-    // A higher useCount indicates a higher priority.
-    return first->script()->getUseCount() / first->script()->length() >
-           second->script()->getUseCount() / second->script()->length();
+    // A higher warm-up counter indicates a higher priority.
+    return first->script()->getWarmUpCounter() / first->script()->length() >
+           second->script()->getWarmUpCounter() / second->script()->length();
 }
 
 bool
 GlobalHelperThreadState::canStartIonCompile()
 {
     return !ionWorklist().empty();
 }
 
--- a/js/src/vm/Interpreter-inl.h
+++ b/js/src/vm/Interpreter-inl.h
@@ -732,18 +732,18 @@ class FastInvokeGuard
                 JS_ASSERT(result == jit::IonExec_Ok);
                 return true;
             }
 
             JS_ASSERT(status == jit::Method_Skipped);
 
             if (script_->canIonCompile()) {
                 // This script is not yet hot. Since calling into Ion is much
-                // faster here, bump the use count a bit to account for this.
-                script_->incUseCount(5);
+                // faster here, bump the warm-up counter a bit to account for this.
+                script_->incWarmUpCounter(5);
             }
         }
 
         return Invoke(cx, args_);
     }
 
   private:
     FastInvokeGuard(const FastInvokeGuard& other) MOZ_DELETE;
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/js/xpconnect/src/XPCJSRuntime.cpp
@@ -1498,19 +1498,19 @@ ReloadPrefsCallback(const char *pref, vo
                              .setIon(useIon)
                              .setAsmJS(useAsmJS)
                              .setNativeRegExp(useNativeRegExp)
                              .setWerror(werror)
                              .setExtraWarnings(extraWarnings);
 
     JS_SetParallelParsingEnabled(rt, parallelParsing);
     JS_SetOffthreadIonCompilationEnabled(rt, offthreadIonCompilation);
-    JS_SetGlobalJitCompilerOption(rt, JSJITCOMPILER_BASELINE_USECOUNT_TRIGGER,
+    JS_SetGlobalJitCompilerOption(rt, JSJITCOMPILER_BASELINE_WARMUP_TRIGGER,
                                   useBaselineEager ? 0 : -1);
-    JS_SetGlobalJitCompilerOption(rt, JSJITCOMPILER_ION_USECOUNT_TRIGGER,
+    JS_SetGlobalJitCompilerOption(rt, JSJITCOMPILER_ION_WARMUP_TRIGGER,
                                   useIonEager ? 0 : -1);
 }
 
 XPCJSRuntime::~XPCJSRuntime()
 {
     // This destructor runs before ~CycleCollectedJSRuntime, which does the
     // actual JS_DestroyRuntime() call. But destroying the runtime triggers
     // one final GC, which can call back into the runtime with various