Bug 1102538 - s/Ion/Jit/ where appropriate. r=jandem.
authorNicholas Nethercote <nnethercote@mozilla.com>
Mon, 24 Nov 2014 18:52:39 -0800
changeset 217624 b5136e8cd58e16ca8994d434a4fb4b9a55a67526
parent 217623 8663be2ce7cfd14b44dc3e51c5e879f2ffa537d1
child 217625 5f1b17ceebe48984dc35c0de46f8c325931479ab
push id12432
push userryanvm@gmail.com
push dateThu, 27 Nov 2014 02:40:29 +0000
treeherderb2g-inbound@cef590a6f946 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem
bugs1102538
milestone36.0a1
Bug 1102538 - s/Ion/Jit/ where appropriate. r=jandem.
js/src/asmjs/AsmJSFrameIterator.cpp
js/src/asmjs/AsmJSModule.h
js/src/asmjs/AsmJSValidate.cpp
js/src/gc/ForkJoinNursery.cpp
js/src/gc/Nursery.cpp
js/src/gc/RootMarking.cpp
js/src/irregexp/NativeRegExpMacroAssembler.cpp
js/src/irregexp/RegExpEngine.cpp
js/src/irregexp/RegExpMacroAssembler.h
js/src/jit/AliasAnalysis.cpp
js/src/jit/BacktrackingAllocator.h
js/src/jit/Bailouts.cpp
js/src/jit/Bailouts.h
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineDebugModeOSR.cpp
js/src/jit/BaselineFrame.cpp
js/src/jit/BaselineFrame.h
js/src/jit/BaselineFrameInfo.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineInspector.h
js/src/jit/BaselineJIT.cpp
js/src/jit/BaselineJIT.h
js/src/jit/BitSet.h
js/src/jit/BytecodeAnalysis.cpp
js/src/jit/BytecodeAnalysis.h
js/src/jit/CodeGenerator.cpp
js/src/jit/CodeGenerator.h
js/src/jit/CompileInfo-inl.h
js/src/jit/CompileInfo.h
js/src/jit/CompileWrappers.h
js/src/jit/FixedList.h
js/src/jit/Ion.cpp
js/src/jit/Ion.h
js/src/jit/IonAllocPolicy.h
js/src/jit/IonAnalysis.cpp
js/src/jit/IonAnalysis.h
js/src/jit/IonBuilder.cpp
js/src/jit/IonBuilder.h
js/src/jit/IonCaches.cpp
js/src/jit/IonCode.h
js/src/jit/IonFrames-inl.h
js/src/jit/IonFrames.cpp
js/src/jit/IonFrames.h
js/src/jit/IonLinker.h
js/src/jit/IonMacroAssembler.cpp
js/src/jit/IonMacroAssembler.h
js/src/jit/JSONSpewer.cpp
js/src/jit/JitAllocPolicy.h
js/src/jit/JitCompartment.h
js/src/jit/JitFrameIterator-inl.h
js/src/jit/JitFrameIterator.h
js/src/jit/JitFrames-inl.h
js/src/jit/JitFrames.cpp
js/src/jit/JitFrames.h
js/src/jit/JitSpewer.cpp
js/src/jit/LIR-Common.h
js/src/jit/LIR.h
js/src/jit/Label.h
js/src/jit/Linker.h
js/src/jit/LiveRangeAllocator.h
js/src/jit/Lowering.cpp
js/src/jit/MCallOptimize.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/MIRGenerator.h
js/src/jit/MIRGraph.h
js/src/jit/MacroAssembler.cpp
js/src/jit/MacroAssembler.h
js/src/jit/MoveResolver.h
js/src/jit/ParallelFunctions.cpp
js/src/jit/ParallelSafetyAnalysis.h
js/src/jit/PerfSpewer.h
js/src/jit/RangeAnalysis.cpp
js/src/jit/Recover.cpp
js/src/jit/RegisterSets.h
js/src/jit/RematerializedFrame.cpp
js/src/jit/RematerializedFrame.h
js/src/jit/TypePolicy.h
js/src/jit/TypedObjectPrediction.h
js/src/jit/VMFunctions.cpp
js/src/jit/VMFunctions.h
js/src/jit/ValueNumbering.h
js/src/jit/arm/Assembler-arm.h
js/src/jit/arm/Bailouts-arm.cpp
js/src/jit/arm/BaselineHelpers-arm.h
js/src/jit/arm/BaselineIC-arm.cpp
js/src/jit/arm/BaselineRegisters-arm.h
js/src/jit/arm/CodeGenerator-arm.cpp
js/src/jit/arm/MacroAssembler-arm.cpp
js/src/jit/arm/MacroAssembler-arm.h
js/src/jit/arm/MoveEmitter-arm.h
js/src/jit/arm/Trampoline-arm.cpp
js/src/jit/mips/Bailouts-mips.cpp
js/src/jit/mips/BaselineHelpers-mips.h
js/src/jit/mips/BaselineIC-mips.cpp
js/src/jit/mips/BaselineRegisters-mips.h
js/src/jit/mips/CodeGenerator-mips.cpp
js/src/jit/mips/MacroAssembler-mips.cpp
js/src/jit/mips/MacroAssembler-mips.h
js/src/jit/mips/MoveEmitter-mips.h
js/src/jit/mips/Trampoline-mips.cpp
js/src/jit/none/BaselineRegisters-none.h
js/src/jit/none/MacroAssembler-none.h
js/src/jit/none/MoveEmitter-none.h
js/src/jit/shared/Assembler-shared.h
js/src/jit/shared/BaselineCompiler-shared.h
js/src/jit/shared/CodeGenerator-shared.cpp
js/src/jit/shared/CodeGenerator-shared.h
js/src/jit/shared/CodeGenerator-x86-shared.cpp
js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
js/src/jit/shared/MacroAssembler-x86-shared.cpp
js/src/jit/shared/MacroAssembler-x86-shared.h
js/src/jit/x64/Bailouts-x64.cpp
js/src/jit/x64/BaselineHelpers-x64.h
js/src/jit/x64/BaselineRegisters-x64.h
js/src/jit/x64/MacroAssembler-x64.cpp
js/src/jit/x64/MacroAssembler-x64.h
js/src/jit/x64/Trampoline-x64.cpp
js/src/jit/x86/Bailouts-x86.cpp
js/src/jit/x86/BaselineHelpers-x86.h
js/src/jit/x86/BaselineIC-x86.cpp
js/src/jit/x86/BaselineRegisters-x86.h
js/src/jit/x86/MacroAssembler-x86.cpp
js/src/jit/x86/MacroAssembler-x86.h
js/src/jit/x86/Trampoline-x86.cpp
js/src/jsapi-tests/testJitMoveEmitterCycles-mips.cpp
js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
js/src/jscntxt.h
js/src/jscntxtinlines.h
js/src/jsfun.h
js/src/jsinfer.cpp
js/src/jsinfer.h
js/src/jsscript.cpp
js/src/moz.build
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArgumentsObject.h
js/src/vm/Debugger.cpp
js/src/vm/ForkJoin.cpp
js/src/vm/HelperThreads.cpp
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/src/vm/Stack.cpp
js/src/vm/Stack.h
js/src/vm/TraceLogging.cpp
--- a/js/src/asmjs/AsmJSFrameIterator.cpp
+++ b/js/src/asmjs/AsmJSFrameIterator.cpp
@@ -15,17 +15,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #include "asmjs/AsmJSFrameIterator.h"
 
 #include "asmjs/AsmJSModule.h"
 #include "asmjs/AsmJSValidate.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 using namespace js;
 using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 /*****************************************************************************/
 // AsmJSFrameIterator implementation
--- a/js/src/asmjs/AsmJSModule.h
+++ b/js/src/asmjs/AsmJSModule.h
@@ -24,18 +24,18 @@
 #include "mozilla/PodOperations.h"
 
 #include "jsscript.h"
 
 #include "asmjs/AsmJSFrameIterator.h"
 #include "asmjs/AsmJSValidate.h"
 #include "builtin/SIMD.h"
 #include "gc/Marking.h"
-#include "jit/IonMacroAssembler.h"
 #include "jit/IonTypes.h"
+#include "jit/MacroAssembler.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/RegisterSets.h"
 #include "jit/shared/Assembler-shared.h"
 #include "vm/TypedArrayObject.h"
 
 namespace js {
--- a/js/src/asmjs/AsmJSValidate.cpp
+++ b/js/src/asmjs/AsmJSValidate.cpp
@@ -2288,17 +2288,17 @@ class FunctionCompiler
     LocalMap               locals_;
     VarInitializerVector   varInitializers_;
     Maybe<RetType>         alreadyReturned_;
 
     TempAllocator *        alloc_;
     MIRGraph *             graph_;
     CompileInfo *          info_;
     MIRGenerator *         mirGen_;
-    Maybe<IonContext>      ionContext_;
+    Maybe<JitContext>      jitContext_;
 
     MBasicBlock *          curBlock_;
 
     NodeStack              loopStack_;
     NodeStack              breakableStack_;
     UnlabeledBlockMap      unlabeledBreaks_;
     UnlabeledBlockMap      unlabeledContinues_;
     LabeledBlockMap        labeledBreaks_;
@@ -2396,17 +2396,17 @@ class FunctionCompiler
         return varInitializers_.append(init);
     }
 
     bool prepareToEmitMIR(const VarTypeVector &argTypes)
     {
         MOZ_ASSERT(locals_.count() == argTypes.length() + varInitializers_.length());
 
         alloc_  = lifo_.new_<TempAllocator>(&lifo_);
-        ionContext_.emplace(m_.cx(), alloc_);
+        jitContext_.emplace(m_.cx(), alloc_);
 
         graph_  = lifo_.new_<MIRGraph>(alloc_);
         info_   = lifo_.new_<CompileInfo>(locals_.count(), SequentialExecution);
         const OptimizationInfo *optimizationInfo = js_IonOptimizations.get(Optimization_AsmJS);
         const JitCompileOptions options;
         mirGen_ = lifo_.new_<MIRGenerator>(CompileCompartment::get(cx()->compartment()),
                                            options, alloc_,
                                            graph_, info_, optimizationInfo);
@@ -7575,17 +7575,17 @@ CheckFunctionsSequential(ModuleCompiler 
             return false;
 
         // In the case of the change-heap function, no MIR is produced.
         if (!mir)
             continue;
 
         int64_t before = PRMJ_Now();
 
-        IonContext icx(m.cx(), &mir->alloc());
+        JitContext jcx(m.cx(), &mir->alloc());
 
         IonSpewNewFunction(&mir->graph(), NullPtr());
 
         if (!OptimizeMIR(mir))
             return m.failOffset(func->srcBegin(), "internal compiler failure (probably out of memory)");
 
         LIRGraph *lir = GenerateLIR(mir);
         if (!lir)
@@ -7682,17 +7682,17 @@ GetUsedTask(ModuleCompiler &m, ParallelG
     if (!task)
         return false;
 
     ModuleCompiler::Func &func = *reinterpret_cast<ModuleCompiler::Func *>(task->func);
     func.accumulateCompileTime(task->compileTime);
 
     {
         // Perform code generation on the main thread.
-        IonContext ionContext(m.cx(), &task->mir->alloc());
+        JitContext jitContext(m.cx(), &task->mir->alloc());
         if (!GenerateCode(m, func, *task->mir, *task->lir))
             return false;
     }
 
     group.compiledJobs++;
 
     // Clear the LifoAlloc for use by another helper.
     TempAllocator &tempAlloc = task->mir->alloc();
@@ -9042,17 +9042,17 @@ GenerateStubs(ModuleCompiler &m)
 }
 
 static bool
 FinishModule(ModuleCompiler &m,
              ScopedJSDeletePtr<AsmJSModule> *module)
 {
     LifoAlloc lifo(TempAllocator::PreferredLifoChunkSize);
     TempAllocator alloc(&lifo);
-    IonContext ionContext(m.cx(), &alloc);
+    JitContext jitContext(m.cx(), &alloc);
 
     m.masm().resetForNewCodeGenerator(alloc);
 
     if (!GenerateStubs(m))
         return false;
 
     return m.finish(module);
 }
--- a/js/src/gc/ForkJoinNursery.cpp
+++ b/js/src/gc/ForkJoinNursery.cpp
@@ -9,17 +9,17 @@
 
 #include "gc/ForkJoinNursery-inl.h"
 
 #include "mozilla/IntegerPrintfMacros.h"
 
 #include "prmjtime.h"
 
 #include "gc/Heap.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/RematerializedFrame.h"
 #include "vm/ArrayObject.h"
 #include "vm/ForkJoin.h"
 
 #include "jsgcinlines.h"
 #include "gc/Nursery-inl.h"
 #include "vm/NativeObject-inl.h"
 
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -14,17 +14,17 @@
 #include "jscompartment.h"
 #include "jsgc.h"
 #include "jsinfer.h"
 #include "jsutil.h"
 #include "prmjtime.h"
 
 #include "gc/GCInternals.h"
 #include "gc/Memory.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "vm/ArrayObject.h"
 #include "vm/Debugger.h"
 #if defined(DEBUG)
 #include "vm/ScopeObject.h"
 #endif
 #include "vm/TypedArrayObject.h"
 
 #include "jsgcinlines.h"
--- a/js/src/gc/RootMarking.cpp
+++ b/js/src/gc/RootMarking.cpp
@@ -16,17 +16,17 @@
 #include "jstypes.h"
 #include "jswatchpoint.h"
 
 #include "builtin/MapObject.h"
 #include "frontend/BytecodeCompiler.h"
 #include "gc/ForkJoinNursery.h"
 #include "gc/GCInternals.h"
 #include "gc/Marking.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 #include "js/HashTable.h"
 #include "vm/Debugger.h"
 #include "vm/JSONParser.h"
 #include "vm/PropDesc.h"
 
 #include "jsgcinlines.h"
 #include "jsobjinlines.h"
 
--- a/js/src/irregexp/NativeRegExpMacroAssembler.cpp
+++ b/js/src/irregexp/NativeRegExpMacroAssembler.cpp
@@ -26,17 +26,17 @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "irregexp/NativeRegExpMacroAssembler.h"
 
 #include "irregexp/RegExpStack.h"
-#include "jit/IonLinker.h"
+#include "jit/Linker.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "vm/MatchPairs.h"
 
 using namespace js;
 using namespace js::irregexp;
 using namespace js::jit;
--- a/js/src/irregexp/RegExpEngine.cpp
+++ b/js/src/irregexp/RegExpEngine.cpp
@@ -1717,17 +1717,17 @@ irregexp::CompilePattern(JSContext *cx, 
 
     Analysis analysis(cx, ignore_case, is_ascii);
     analysis.EnsureAnalyzed(node);
     if (analysis.has_failed()) {
         JS_ReportError(cx, analysis.errorMessage());
         return RegExpCode();
     }
 
-    Maybe<jit::IonContext> ctx;
+    Maybe<jit::JitContext> ctx;
     Maybe<NativeRegExpMacroAssembler> native_assembler;
     Maybe<InterpretedRegExpMacroAssembler> interpreted_assembler;
 
     RegExpMacroAssembler *assembler;
     if (IsNativeRegExpEnabled(cx) && !force_bytecode) {
         NativeRegExpMacroAssembler::Mode mode =
             is_ascii ? NativeRegExpMacroAssembler::ASCII
                      : NativeRegExpMacroAssembler::CHAR16;
--- a/js/src/irregexp/RegExpMacroAssembler.h
+++ b/js/src/irregexp/RegExpMacroAssembler.h
@@ -28,17 +28,17 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_REGEXP_MACRO_ASSEMBLER_H_
 #define V8_REGEXP_MACRO_ASSEMBLER_H_
 
 #include "irregexp/RegExpAST.h"
 #include "irregexp/RegExpEngine.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace irregexp {
 
 class MOZ_STACK_CLASS RegExpMacroAssembler
 {
   public:
     RegExpMacroAssembler(LifoAlloc &alloc, RegExpShared *shared, size_t numSavedRegisters)
--- a/js/src/jit/AliasAnalysis.cpp
+++ b/js/src/jit/AliasAnalysis.cpp
@@ -158,17 +158,17 @@ IonSpewAliasInfo(const char *pre, MInstr
 // having an implicit dependency on the last instruction of the loop header, so that
 // it's never moved before the loop header.
 //
 // The algorithm depends on the invariant that both control instructions and effectful
 // instructions (stores) are never hoisted.
 bool
 AliasAnalysis::analyze()
 {
-    Vector<MInstructionVector, AliasSet::NumCategories, IonAllocPolicy> stores(alloc());
+    Vector<MInstructionVector, AliasSet::NumCategories, JitAllocPolicy> stores(alloc());
 
     // Initialize to the first instruction.
     MInstruction *firstIns = *graph_.entryBlock()->begin();
     for (unsigned i = 0; i < AliasSet::NumCategories; i++) {
         MInstructionVector defs(alloc());
         if (!defs.append(firstIns))
             return false;
         if (!stores.append(Move(defs)))
--- a/js/src/jit/BacktrackingAllocator.h
+++ b/js/src/jit/BacktrackingAllocator.h
@@ -23,17 +23,17 @@ namespace jit {
 
 // Information about a group of registers. Registers may be grouped together
 // when (a) all of their lifetimes are disjoint, (b) they are of the same type
 // (double / non-double) and (c) it is desirable that they have the same
 // allocation.
 struct VirtualRegisterGroup : public TempObject
 {
     // All virtual registers in the group.
-    Vector<uint32_t, 2, IonAllocPolicy> registers;
+    Vector<uint32_t, 2, JitAllocPolicy> registers;
 
     // Desired physical register to use for registers in the group.
     LAllocation allocation;
 
     // Spill location to be shared by registers in the group.
     LAllocation spill;
 
     explicit VirtualRegisterGroup(TempAllocator &alloc)
--- a/js/src/jit/Bailouts.cpp
+++ b/js/src/jit/Bailouts.cpp
@@ -27,17 +27,17 @@ using mozilla::IsInRange;
 uint32_t
 jit::Bailout(BailoutStack *sp, BaselineBailoutInfo **bailoutInfo)
 {
     JSContext *cx = GetJSContextFromJitCode();
     MOZ_ASSERT(bailoutInfo);
 
     // We don't have an exit frame.
     MOZ_ASSERT(IsInRange(FAKE_JIT_TOP_FOR_BAILOUT, 0, 0x1000) &&
-               IsInRange(FAKE_JIT_TOP_FOR_BAILOUT + sizeof(IonCommonFrameLayout), 0, 0x1000),
+               IsInRange(FAKE_JIT_TOP_FOR_BAILOUT + sizeof(CommonFrameLayout), 0, 0x1000),
                "Fake jitTop pointer should be within the first page.");
     cx->mainThread().jitTop = FAKE_JIT_TOP_FOR_BAILOUT;
 
     JitActivationIterator jitActivations(cx->runtime());
     BailoutFrameInfo bailoutData(jitActivations, sp);
     JitFrameIterator iter(jitActivations);
     MOZ_ASSERT(!iter.ionScript()->invalidated());
 
@@ -139,17 +139,17 @@ jit::InvalidationBailout(InvalidationBai
         // pseudostack frame would not have been pushed in the first
         // place, so don't pop anything in that case.
         bool popSPSFrame = iter.ionScript()->hasSPSInstrumentation() &&
                            (SnapshotIterator(iter).bailoutKind() != Bailout_ArgumentCheck) &&
                            !poppedLastSPSFrame;
         JSScript *script = iter.script();
         probes::ExitScript(cx, script, script->functionNonDelazifying(), popSPSFrame);
 
-        IonJSFrameLayout *frame = iter.jsFrame();
+        JitFrameLayout *frame = iter.jsFrame();
         JitSpew(JitSpew_IonInvalidate, "Bailout failed (%s): converting to exit frame",
                 (retval == BAILOUT_RETURN_FATAL_ERROR) ? "Fatal Error" : "Over Recursion");
         JitSpew(JitSpew_IonInvalidate, "   orig calleeToken %p", (void *) frame->calleeToken());
         JitSpew(JitSpew_IonInvalidate, "   orig frameSize %u", unsigned(frame->prevFrameLocalSize()));
         JitSpew(JitSpew_IonInvalidate, "   orig ra %p", (void *) frame->returnAddress());
 
         frame->replaceCalleeToken(nullptr);
         EnsureExitFrame(frame);
--- a/js/src/jit/Bailouts.h
+++ b/js/src/jit/Bailouts.h
@@ -4,18 +4,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_Bailouts_h
 #define jit_Bailouts_h
 
 #include "jstypes.h"
 
-#include "jit/IonFrames.h"
 #include "jit/JitFrameIterator.h"
+#include "jit/JitFrames.h"
 #include "vm/Stack.h"
 
 namespace js {
 namespace jit {
 
 // A "bailout" is a condition in which we need to recover an interpreter frame
 // from an IonFrame. Bailouts can happen for the following reasons:
 //   (1) A deoptimization guard, for example, an add overflows or a type check
@@ -81,17 +81,17 @@ namespace jit {
 // Then, we can provide a per-script mapping from BailoutIds to snapshots,
 // which takes only four bytes per entry.
 //
 // This strategy does not work as given, because the bailout handler has no way
 // to compute the location of an IonScript. Currently, we do not use frame
 // pointers. To account for this we segregate frames into a limited set of
 // "frame sizes", and create a table for each frame size. We also have the
 // option of not using bailout tables, for platforms or situations where the
-// 10 byte cost is more optimal than a bailout table. See IonFrames.h for more
+// 10 byte cost is more optimal than a bailout table. See JitFrames.h for more
 // detail.
 
 static const BailoutId INVALID_BAILOUT_ID = BailoutId(-1);
 
 // Keep this arbitrarily small for now, for testing.
 static const uint32_t BAILOUT_TABLE_SIZE = 16;
 
 // Bailout return codes.
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -15,17 +15,17 @@
 #include "jit/RematerializedFrame.h"
 
 #include "vm/ArgumentsObject.h"
 #include "vm/Debugger.h"
 #include "vm/TraceLogging.h"
 
 #include "jsscriptinlines.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 // BaselineStackBuilder may reallocate its buffer if the current one is too
 // small. To avoid dangling pointers, BufferPointer represents a pointer into
 // this buffer as a pointer to the header and a fixed offset.
 template <typename T>
@@ -70,32 +70,32 @@ class BufferPointer
  * data that's written to the reconstructed stack grows from high to low in memory.
  *
  * The lowest region of the allocated memory contains a BaselineBailoutInfo structure that
  * points to the start and end of the written data.
  */
 struct BaselineStackBuilder
 {
     JitFrameIterator &iter_;
-    IonJSFrameLayout *frame_;
+    JitFrameLayout *frame_;
 
     static size_t HeaderSize() {
         return AlignBytes(sizeof(BaselineBailoutInfo), sizeof(void *));
     }
     size_t bufferTotal_;
     size_t bufferAvail_;
     size_t bufferUsed_;
     uint8_t *buffer_;
     BaselineBailoutInfo *header_;
 
     size_t framePushed_;
 
     BaselineStackBuilder(JitFrameIterator &iter, size_t initialSize)
       : iter_(iter),
-        frame_(static_cast<IonJSFrameLayout*>(iter.current())),
+        frame_(static_cast<JitFrameLayout*>(iter.current())),
         bufferTotal_(initialSize),
         bufferAvail_(0),
         bufferUsed_(0),
         buffer_(nullptr),
         header_(nullptr),
         framePushed_(0)
     {
         MOZ_ASSERT(bufferTotal_ >= HeaderSize());
@@ -295,87 +295,87 @@ struct BaselineStackBuilder
     }
 
     inline uint8_t *virtualPointerAtStackOffset(size_t offset) {
         if (offset < bufferUsed_)
             return reinterpret_cast<uint8_t *>(frame_) - (bufferUsed_ - offset);
         return reinterpret_cast<uint8_t *>(frame_) + (offset - bufferUsed_);
     }
 
-    inline IonJSFrameLayout *startFrame() {
+    inline JitFrameLayout *startFrame() {
         return frame_;
     }
 
-    BufferPointer<IonJSFrameLayout> topFrameAddress() {
-        return pointerAtStackOffset<IonJSFrameLayout>(0);
+    BufferPointer<JitFrameLayout> topFrameAddress() {
+        return pointerAtStackOffset<JitFrameLayout>(0);
     }
 
     //
     // This method should only be called when the builder is in a state where it is
     // starting to construct the stack frame for the next callee.  This means that
     // the lowest value on the constructed stack is the return address for the previous
     // caller frame.
     //
     // This method is used to compute the value of the frame pointer (e.g. ebp on x86)
     // that would have been saved by the baseline jitcode when it was entered.  In some
     // cases, this value can be bogus since we can ensure that the caller would have saved
     // it anyway.
     //
     void *calculatePrevFramePtr() {
         // Get the incoming frame.
-        BufferPointer<IonJSFrameLayout> topFrame = topFrameAddress();
+        BufferPointer<JitFrameLayout> topFrame = topFrameAddress();
         FrameType type = topFrame->prevType();
 
         // For IonJS and Entry frames, the "saved" frame pointer in the baseline
         // frame is meaningless, since Ion saves all registers before calling other ion
         // frames, and the entry frame saves all registers too.
         if (type == JitFrame_IonJS || type == JitFrame_Entry)
             return nullptr;
 
         // BaselineStub - Baseline calling into Ion.
         //  PrevFramePtr needs to point to the BaselineStubFrame's saved frame pointer.
-        //      STACK_START_ADDR + IonJSFrameLayout::Size() + PREV_FRAME_SIZE
-        //                      - IonBaselineStubFrameLayout::reverseOffsetOfSavedFramePtr()
+        //      STACK_START_ADDR + JitFrameLayout::Size() + PREV_FRAME_SIZE
+        //                      - BaselineStubFrameLayout::reverseOffsetOfSavedFramePtr()
         if (type == JitFrame_BaselineStub) {
-            size_t offset = IonJSFrameLayout::Size() + topFrame->prevFrameLocalSize() +
-                            IonBaselineStubFrameLayout::reverseOffsetOfSavedFramePtr();
+            size_t offset = JitFrameLayout::Size() + topFrame->prevFrameLocalSize() +
+                            BaselineStubFrameLayout::reverseOffsetOfSavedFramePtr();
             return virtualPointerAtStackOffset(offset);
         }
 
         MOZ_ASSERT(type == JitFrame_Rectifier);
         // Rectifier - behaviour depends on the frame preceding the rectifier frame, and
         // whether the arch is x86 or not.  The x86 rectifier frame saves the frame pointer,
         // so we can calculate it directly.  For other archs, the previous frame pointer
         // is stored on the stack in the frame that precedes the rectifier frame.
-        size_t priorOffset = IonJSFrameLayout::Size() + topFrame->prevFrameLocalSize();
+        size_t priorOffset = JitFrameLayout::Size() + topFrame->prevFrameLocalSize();
 #if defined(JS_CODEGEN_X86)
         // On X86, the FramePointer is pushed as the first value in the Rectifier frame.
         MOZ_ASSERT(BaselineFrameReg == FramePointer);
         priorOffset -= sizeof(void *);
         return virtualPointerAtStackOffset(priorOffset);
 #elif defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_ARM) || defined(JS_CODEGEN_MIPS)
         // On X64, ARM and MIPS, the frame pointer save location depends on
         // the caller of the rectifier frame.
-        BufferPointer<IonRectifierFrameLayout> priorFrame =
-            pointerAtStackOffset<IonRectifierFrameLayout>(priorOffset);
+        BufferPointer<RectifierFrameLayout> priorFrame =
+            pointerAtStackOffset<RectifierFrameLayout>(priorOffset);
         FrameType priorType = priorFrame->prevType();
         MOZ_ASSERT(priorType == JitFrame_IonJS || priorType == JitFrame_BaselineStub);
 
         // If the frame preceding the rectifier is an IonJS frame, then once again
         // the frame pointer does not matter.
         if (priorType == JitFrame_IonJS)
             return nullptr;
 
         // Otherwise, the frame preceding the rectifier is a BaselineStub frame.
-        //  let X = STACK_START_ADDR + IonJSFrameLayout::Size() + PREV_FRAME_SIZE
-        //      X + IonRectifierFrameLayout::Size()
-        //        + ((IonRectifierFrameLayout *) X)->prevFrameLocalSize()
+        //  let X = STACK_START_ADDR + JitFrameLayout::Size() + PREV_FRAME_SIZE
+        //      X + RectifierFrameLayout::Size()
+        //        + ((RectifierFrameLayout *) X)->prevFrameLocalSize()
         //        - BaselineStubFrameLayout::reverseOffsetOfSavedFramePtr()
-        size_t extraOffset = IonRectifierFrameLayout::Size() + priorFrame->prevFrameLocalSize() +
-                             IonBaselineStubFrameLayout::reverseOffsetOfSavedFramePtr();
+        size_t extraOffset = RectifierFrameLayout::Size() + priorFrame->prevFrameLocalSize() +
+                             BaselineStubFrameLayout::reverseOffsetOfSavedFramePtr();
         return virtualPointerAtStackOffset(priorOffset + extraOffset);
 #elif defined(JS_CODEGEN_NONE)
         MOZ_CRASH();
 #else
 #  error "Bad architecture!"
 #endif
     }
 };
@@ -714,17 +714,17 @@ InitFromBailout(JSContext *cx, HandleScr
 
     if (fun) {
         // The unpacked thisv and arguments should overwrite the pushed args present
         // in the calling frame.
         Value thisv = iter.read();
         JitSpew(JitSpew_BaselineBailouts, "      Is function!");
         JitSpew(JitSpew_BaselineBailouts, "      thisv=%016llx", *((uint64_t *) &thisv));
 
-        size_t thisvOffset = builder.framePushed() + IonJSFrameLayout::offsetOfThis();
+        size_t thisvOffset = builder.framePushed() + JitFrameLayout::offsetOfThis();
         *builder.valuePointerAtStackOffset(thisvOffset) = thisv;
 
         MOZ_ASSERT(iter.numAllocations() >= CountArgSlots(script, fun));
         JitSpew(JitSpew_BaselineBailouts, "      frame slots %u, nargs %u, nfixed %u",
                 iter.numAllocations(), fun->nargs(), script->nfixed());
 
         if (!callerPC) {
             // This is the first frame. Store the formals in a Vector until we
@@ -737,17 +737,17 @@ InitFromBailout(JSContext *cx, HandleScr
                 return false;
         }
 
         for (uint32_t i = 0; i < fun->nargs(); i++) {
             Value arg = iter.read();
             JitSpew(JitSpew_BaselineBailouts, "      arg %d = %016llx",
                         (int) i, *((uint64_t *) &arg));
             if (callerPC) {
-                size_t argOffset = builder.framePushed() + IonJSFrameLayout::offsetOfActualArg(i);
+                size_t argOffset = builder.framePushed() + JitFrameLayout::offsetOfActualArg(i);
                 *builder.valuePointerAtStackOffset(argOffset) = arg;
             } else {
                 startFrameFormals[i].set(arg);
             }
         }
     }
 
     for (uint32_t i = 0; i < script->nfixed(); i++) {
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -8,19 +8,19 @@
 
 #include "mozilla/UniquePtr.h"
 
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/FixedList.h"
 #include "jit/IonAnalysis.h"
-#include "jit/IonLinker.h"
 #include "jit/JitcodeMap.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/VMFunctions.h"
 #include "vm/TraceLogging.h"
 
 #include "jsscriptinlines.h"
 
--- a/js/src/jit/BaselineDebugModeOSR.cpp
+++ b/js/src/jit/BaselineDebugModeOSR.cpp
@@ -3,22 +3,21 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/BaselineDebugModeOSR.h"
 
 #include "mozilla/DebugOnly.h"
 
-#include "jit/IonLinker.h"
-
 #include "jit/JitcodeMap.h"
+#include "jit/Linker.h"
 #include "jit/PerfSpewer.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 struct DebugModeOSREntry
@@ -210,17 +209,17 @@ CollectJitStackScripts(JSContext *cx, co
             }
             entries.back().oldStub = prevFrameStubPtr;
             prevFrameStubPtr = nullptr;
             break;
           }
 
           case JitFrame_BaselineStub:
             prevFrameStubPtr =
-                reinterpret_cast<IonBaselineStubFrameLayout *>(iter.fp())->maybeStubPtr();
+                reinterpret_cast<BaselineStubFrameLayout *>(iter.fp())->maybeStubPtr();
             break;
 
           case JitFrame_IonJS: {
             InlineFrameIterator inlineIter(cx, &iter);
             while (true) {
                 if (obs.shouldRecompileOrInvalidate(inlineIter.script())) {
                     if (!entries.append(DebugModeOSREntry(inlineIter.script())))
                         return false;
@@ -335,17 +334,17 @@ PatchBaselineFramesForDebugMode(JSContex
     //  G. Undo cases B, C, D, or E above on previously patched yet unpopped
     //     frames.
     //
     // In general, we patch the return address from the VM call to return to a
     // "continuation fixer" to fix up machine state (registers and stack
     // state). Specifics on what need to be done are documented below.
     //
 
-    IonCommonFrameLayout *prev = nullptr;
+    CommonFrameLayout *prev = nullptr;
     size_t entryIndex = *start;
 
     for (JitFrameIterator iter(activation); !iter.done(); ++iter) {
         switch (iter.type()) {
           case JitFrame_BaselineJS: {
             // If the script wasn't recompiled or is not observed, there's
             // nothing to patch.
             if (!obs.shouldRecompileOrInvalidate(iter.script()))
@@ -497,18 +496,18 @@ PatchBaselineFramesForDebugMode(JSContex
                 break;
 
             DebugModeOSREntry &entry = entries[entryIndex];
 
             // If the script wasn't recompiled, there's nothing to patch.
             if (!entry.recompiled())
                 break;
 
-            IonBaselineStubFrameLayout *layout =
-                reinterpret_cast<IonBaselineStubFrameLayout *>(iter.fp());
+            BaselineStubFrameLayout *layout =
+                reinterpret_cast<BaselineStubFrameLayout *>(iter.fp());
             MOZ_ASSERT(layout->maybeStubPtr() == entry.oldStub);
 
             // Patch baseline stub frames for case A above.
             //
             // We need to patch the stub frame to point to an ICStub belonging
             // to the recompiled baseline script. These stubs are allocated up
             // front in CloneOldBaselineStub. They share the same JitCode as
             // the old baseline script's stubs, so we don't need to patch the
--- a/js/src/jit/BaselineFrame.cpp
+++ b/js/src/jit/BaselineFrame.cpp
@@ -6,17 +6,17 @@
 
 #include "jit/BaselineFrame-inl.h"
 
 #include "jit/BaselineJIT.h"
 #include "jit/Ion.h"
 #include "vm/Debugger.h"
 #include "vm/ScopeObject.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 static void
 MarkLocals(BaselineFrame *frame, JSTracer *trc, unsigned start, unsigned end)
 {
--- a/js/src/jit/BaselineFrame.h
+++ b/js/src/jit/BaselineFrame.h
@@ -2,28 +2,28 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_BaselineFrame_h
 #define jit_BaselineFrame_h
 
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "vm/Stack.h"
 
 namespace js {
 namespace jit {
 
 struct BaselineDebugModeOSRInfo;
 
 // The stack looks like this, fp is the frame pointer:
 //
 // fp+y   arguments
-// fp+x   IonJSFrameLayout (frame header)
+// fp+x   JitFrameLayout (frame header)
 // fp  => saved frame pointer
 // fp-x   BaselineFrame
 //        locals
 //        stack values
 
 // Eval frames
 //
 // Like js::InterpreterFrame, every BaselineFrame is either a global frame
@@ -369,33 +369,33 @@ class BaselineFrame
     }
     bool isNonEvalFunctionFrame() const {
         return isFunctionFrame() && !isEvalFrame();
     }
     bool isDebuggerEvalFrame() const {
         return false;
     }
 
-    IonJSFrameLayout *framePrefix() const {
+    JitFrameLayout *framePrefix() const {
         uint8_t *fp = (uint8_t *)this + Size() + FramePointerOffset;
-        return (IonJSFrameLayout *)fp;
+        return (JitFrameLayout *)fp;
     }
 
     // Methods below are used by the compiler.
     static size_t offsetOfCalleeToken() {
-        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfCalleeToken();
+        return FramePointerOffset + js::jit::JitFrameLayout::offsetOfCalleeToken();
     }
     static size_t offsetOfThis() {
-        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfThis();
+        return FramePointerOffset + js::jit::JitFrameLayout::offsetOfThis();
     }
     static size_t offsetOfArg(size_t index) {
-        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfActualArg(index);
+        return FramePointerOffset + js::jit::JitFrameLayout::offsetOfActualArg(index);
     }
     static size_t offsetOfNumActualArgs() {
-        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfNumActualArgs();
+        return FramePointerOffset + js::jit::JitFrameLayout::offsetOfNumActualArgs();
     }
     static size_t Size() {
         return sizeof(BaselineFrame);
     }
 
     // The reverseOffsetOf methods below compute the offset relative to the
     // frame's base pointer. Since the stack grows down, these offsets are
     // negative.
--- a/js/src/jit/BaselineFrameInfo.h
+++ b/js/src/jit/BaselineFrameInfo.h
@@ -7,17 +7,17 @@
 #ifndef jit_BaselineFrameInfo_h
 #define jit_BaselineFrameInfo_h
 
 #include "mozilla/Alignment.h"
 
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/FixedList.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 struct BytecodeInfo;
 
 // FrameInfo overview.
 //
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -11,45 +11,45 @@
 
 #include "jslibmath.h"
 #include "jstypes.h"
 
 #include "builtin/Eval.h"
 #include "jit/BaselineDebugModeOSR.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineJIT.h"
-#include "jit/IonLinker.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #include "jit/Lowering.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/VMFunctions.h"
 #include "vm/Opcodes.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsboolinlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/ScopeObject-inl.h"
 #include "vm/StringObject-inl.h"
 
 using mozilla::DebugOnly;
 
 namespace js {
 namespace jit {
 
 #ifdef DEBUG
 void
 FallbackICSpew(JSContext *cx, ICFallbackStub *stub, const char *fmt, ...)
 {
     if (JitSpewEnabled(JitSpew_BaselineICFallback)) {
-        RootedScript script(cx, GetTopIonJSScript(cx));
+        RootedScript script(cx, GetTopJitJSScript(cx));
         jsbytecode *pc = stub->icEntry()->pc(script);
 
         char fmtbuf[100];
         va_list args;
         va_start(args, fmt);
         vsnprintf(fmtbuf, 100, fmt, args);
         va_end(args);
 
@@ -64,17 +64,17 @@ FallbackICSpew(JSContext *cx, ICFallback
                 fmtbuf);
     }
 }
 
 void
 TypeFallbackICSpew(JSContext *cx, ICTypeMonitor_Fallback *stub, const char *fmt, ...)
 {
     if (JitSpewEnabled(JitSpew_BaselineICFallback)) {
-        RootedScript script(cx, GetTopIonJSScript(cx));
+        RootedScript script(cx, GetTopJitJSScript(cx));
         jsbytecode *pc = stub->icEntry()->pc(script);
 
         char fmtbuf[100];
         va_list args;
         va_start(args, fmt);
         vsnprintf(fmtbuf, 100, fmt, args);
         va_end(args);
 
@@ -613,17 +613,17 @@ ICStubCompiler::getStubCode()
 
     // Check for existing cached stubcode.
     uint32_t stubKey = getKey();
     JitCode *stubCode = comp->getStubCode(stubKey);
     if (stubCode)
         return stubCode;
 
     // Compile new stubcode.
-    IonContext ictx(cx, nullptr);
+    JitContext jctx(cx, nullptr);
     MacroAssembler masm;
 #ifdef JS_CODEGEN_ARM
     masm.setSecondScratchReg(BaselineSecondScratchReg);
 #endif
 
     if (!generateStubCode(masm))
         return nullptr;
     Linker linker(masm);
@@ -1015,17 +1015,17 @@ ICWarmUpCounter_Fallback::Compiler::gene
 
     Label noCompiledCode;
     // 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.
+        // Push JitFrameLayout pointer.
         masm.loadBaselineFramePtr(R0.scratchReg(), R0.scratchReg());
         masm.push(R0.scratchReg());
 
         // Push stub pointer.
         masm.push(BaselineStubReg);
 
         if (!callVM(DoWarmUpCounterFallbackInfo, masm))
             return false;
@@ -4231,17 +4231,17 @@ ICGetElemNativeCompiler::emitCallScripte
     // be clobbered.
     {
         GeneralRegisterSet availRegs = availableGeneralRegs(0);
         availRegs.take(ArgumentsRectifierReg);
         availRegs.take(code);
         emitProfilingUpdate(masm, availRegs, ICGetElemNativeGetterStub::offsetOfPCOffset());
     }
 
-    masm.callIon(code);
+    masm.callJit(code);
 
     leaveStubFrame(masm, true);
 
     return true;
 }
 
 bool
 ICGetElemNativeCompiler::generateStubCode(MacroAssembler &masm)
@@ -7207,17 +7207,17 @@ ICGetProp_CallScripted::Compiler::genera
     }
     Register code = regs.takeAny();
     masm.loadPtr(Address(BaselineStubReg, ICGetProp_CallScripted::offsetOfGetter()), callee);
     masm.branchIfFunctionHasNoScript(callee, &failureLeaveStubFrame);
     masm.loadPtr(Address(callee, JSFunction::offsetOfNativeOrScript()), code);
     masm.loadBaselineOrIonRaw(code, code, SequentialExecution, &failureLeaveStubFrame);
 
     // Getter is called with 0 arguments, just |obj| as thisv.
-    // Note that we use Push, not push, so that callIon will align the stack
+    // Note that we use Push, not push, so that callJit will align the stack
     // properly on ARM.
     masm.Push(R0);
     EmitCreateStubFrameDescriptor(masm, scratch);
     masm.Push(Imm32(0));  // ActualArgc is 0
     masm.Push(callee);
     masm.Push(scratch);
 
     // Handle arguments underflow.
@@ -7242,17 +7242,17 @@ ICGetProp_CallScripted::Compiler::genera
     // be clobbered.
     {
         GeneralRegisterSet availRegs = availableGeneralRegs(0);
         availRegs.take(ArgumentsRectifierReg);
         availRegs.take(code);
         emitProfilingUpdate(masm, availRegs, ICGetProp_CallScripted::offsetOfPCOffset());
     }
 
-    masm.callIon(code);
+    masm.callJit(code);
 
     leaveStubFrame(masm, true);
 
     // Enter type monitor IC to type-check result.
     EmitEnterTypeMonitorIC(masm);
 
     // Leave stub frame and go to next stub.
     masm.bind(&failureLeaveStubFrame);
@@ -8297,17 +8297,17 @@ ICSetProp_CallScripted::Compiler::genera
     }
     Register code = regs.takeAny();
     masm.loadPtr(Address(BaselineStubReg, ICSetProp_CallScripted::offsetOfSetter()), callee);
     masm.branchIfFunctionHasNoScript(callee, &failureLeaveStubFrame);
     masm.loadPtr(Address(callee, JSFunction::offsetOfNativeOrScript()), code);
     masm.loadBaselineOrIonRaw(code, code, SequentialExecution, &failureLeaveStubFrame);
 
     // Setter is called with the new value as the only argument, and |obj| as thisv.
-    // Note that we use Push, not push, so that callIon will align the stack
+    // Note that we use Push, not push, so that callJit will align the stack
     // properly on ARM.
 
     // To Push R1, read it off of the stowed values on stack.
     // Stack: [ ..., R0, R1, ..STUBFRAME-HEADER.. ]
     masm.movePtr(BaselineStackReg, scratch);
     masm.PushValue(Address(scratch, STUB_FRAME_SIZE));
     masm.Push(R0);
     EmitCreateStubFrameDescriptor(masm, scratch);
@@ -8337,17 +8337,17 @@ ICSetProp_CallScripted::Compiler::genera
     // be clobbered.
     {
         GeneralRegisterSet availRegs = availableGeneralRegs(0);
         availRegs.take(ArgumentsRectifierReg);
         availRegs.take(code);
         emitProfilingUpdate(masm, availRegs, ICSetProp_CallScripted::offsetOfPCOffset());
     }
 
-    masm.callIon(code);
+    masm.callJit(code);
 
     leaveStubFrame(masm, true);
     // Do not care about return value from function. The original RHS should be returned
     // as the result of this operation.
     EmitUnstowICValues(masm, 2);
     masm.moveValue(R1, R0);
     EmitReturnFromIC(masm);
 
@@ -9593,17 +9593,17 @@ ICCallScriptedCompiler::generateStubCode
 
     // The callee is on top of the stack. Pop and unbox it.
     ValueOperand val = regs.takeAnyValue();
     masm.popValue(val);
     callee = masm.extractObject(val, ExtractTemp0);
 
     EmitCreateStubFrameDescriptor(masm, scratch);
 
-    // Note that we use Push, not push, so that callIon will align the stack
+    // Note that we use Push, not push, so that callJit will align the stack
     // properly on ARM.
     masm.Push(argcReg);
     masm.PushCalleeToken(callee, isConstructing_);
     masm.Push(scratch);
 
     // Handle arguments underflow.
     Label noUnderflow;
     masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), callee);
@@ -9629,17 +9629,17 @@ ICCallScriptedCompiler::generateStubCode
         GeneralRegisterSet availRegs = availableGeneralRegs(0);
         availRegs.take(ArgumentsRectifierReg);
         availRegs.take(code);
         emitProfilingUpdate(masm, availRegs, kind == ICStub::Call_Scripted ?
                                                 ICCall_Scripted::offsetOfPCOffset()
                                               : ICCall_AnyScripted::offsetOfPCOffset());
     }
 
-    masm.callIon(code);
+    masm.callJit(code);
 
     // If this is a constructing call, and the callee returns a non-object, replace it with
     // the |this| object passed in.
     if (isConstructing_) {
         Label skipThisReplace;
         masm.branchTestObject(Assembler::Equal, JSReturnOperand, &skipThisReplace);
 
         Register scratchReg = JSReturnOperand.scratchReg();
@@ -9887,17 +9887,17 @@ ICCall_Native::Compiler::generateStubCod
 
     // Construct a native exit frame.
     masm.push(argcReg);
 
     Register scratch = regs.takeAny();
     EmitCreateStubFrameDescriptor(masm, scratch);
     masm.push(scratch);
     masm.push(BaselineTailCallReg);
-    masm.enterFakeExitFrame(IonNativeExitFrameLayout::Token());
+    masm.enterFakeExitFrame(NativeExitFrameLayout::Token());
 
     // If needed, update SPS Profiler frame entry.  At this point, BaselineTailCallReg
     // and scratch can be clobbered.
     emitProfilingUpdate(masm, BaselineTailCallReg, scratch, ICCall_Native::offsetOfPCOffset());
 
     // Execute call.
     masm.setupUnalignedABICall(3, scratch);
     masm.loadJSContext(scratch);
@@ -9913,17 +9913,17 @@ ICCall_Native::Compiler::generateStubCod
 #else
     masm.callWithABI(Address(callee, JSFunction::offsetOfNativeOrScript()));
 #endif
 
     // Test for failure.
     masm.branchIfFalseBool(ReturnReg, masm.exceptionLabel());
 
     // Load the return value into R0.
-    masm.loadValue(Address(StackPointer, IonNativeExitFrameLayout::offsetOfResult()), R0);
+    masm.loadValue(Address(StackPointer, NativeExitFrameLayout::offsetOfResult()), R0);
 
     leaveStubFrame(masm);
 
     // Enter type monitor IC to type-check result.
     EmitEnterTypeMonitorIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
@@ -9986,17 +9986,17 @@ ICCall_ClassHook::Compiler::generateStub
     masm.movePtr(StackPointer, vpReg);
 
     // Construct a native exit frame.
     masm.push(argcReg);
 
     EmitCreateStubFrameDescriptor(masm, scratch);
     masm.push(scratch);
     masm.push(BaselineTailCallReg);
-    masm.enterFakeExitFrame(IonNativeExitFrameLayout::Token());
+    masm.enterFakeExitFrame(NativeExitFrameLayout::Token());
 
     // If needed, update SPS Profiler frame entry.  At this point, BaselineTailCallReg
     // and scratch can be clobbered.
     emitProfilingUpdate(masm, BaselineTailCallReg, scratch, ICCall_ClassHook::offsetOfPCOffset());
 
     // Execute call.
     masm.setupUnalignedABICall(3, scratch);
     masm.loadJSContext(scratch);
@@ -10004,17 +10004,17 @@ ICCall_ClassHook::Compiler::generateStub
     masm.passABIArg(argcReg);
     masm.passABIArg(vpReg);
     masm.callWithABI(Address(BaselineStubReg, ICCall_ClassHook::offsetOfNative()));
 
     // Test for failure.
     masm.branchIfFalseBool(ReturnReg, masm.exceptionLabel());
 
     // Load the return value into R0.
-    masm.loadValue(Address(StackPointer, IonNativeExitFrameLayout::offsetOfResult()), R0);
+    masm.loadValue(Address(StackPointer, NativeExitFrameLayout::offsetOfResult()), R0);
 
     leaveStubFrame(masm);
 
     // Enter type monitor IC to type-check result.
     EmitEnterTypeMonitorIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
@@ -10112,17 +10112,17 @@ ICCall_ScriptedApplyArray::Compiler::gen
     regs.add(argcReg);
 
     // If needed, update SPS Profiler frame entry.  At this point, BaselineTailCallReg
     // and scratch can be clobbered.
     emitProfilingUpdate(masm, regs.getAny(), scratch,
                         ICCall_ScriptedApplyArguments::offsetOfPCOffset());
 
     // Do call
-    masm.callIon(target);
+    masm.callJit(target);
     leaveStubFrame(masm, true);
 
     // Enter type monitor IC to type-check result.
     EmitEnterTypeMonitorIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
@@ -10213,17 +10213,17 @@ ICCall_ScriptedApplyArguments::Compiler:
     regs.add(argcReg);
 
     // If needed, update SPS Profiler frame entry.  At this point, BaselineTailCallReg
     // and scratch can be clobbered.
     emitProfilingUpdate(masm, regs.getAny(), scratch,
                         ICCall_ScriptedApplyArguments::offsetOfPCOffset());
 
     // Do call
-    masm.callIon(target);
+    masm.callJit(target);
     leaveStubFrame(masm, true);
 
     // Enter type monitor IC to type-check result.
     EmitEnterTypeMonitorIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
@@ -10304,17 +10304,17 @@ ICCall_ScriptedFunCall::Compiler::genera
     masm.bind(&done);
 
     // Unbox scripted callee.
     callee = masm.extractObject(val, ExtractTemp0);
 
     Register scratch = regs.takeAny();
     EmitCreateStubFrameDescriptor(masm, scratch);
 
-    // Note that we use Push, not push, so that callIon will align the stack
+    // Note that we use Push, not push, so that callJit will align the stack
     // properly on ARM.
     masm.Push(argcReg);
     masm.Push(callee);
     masm.Push(scratch);
 
     // Handle arguments underflow.
     Label noUnderflow;
     masm.load16ZeroExtend(Address(callee, JSFunction::offsetOfNargs()), callee);
@@ -10338,17 +10338,17 @@ ICCall_ScriptedFunCall::Compiler::genera
     {
         // Need to avoid using ArgumentsRectifierReg and code register.
         GeneralRegisterSet availRegs = availableGeneralRegs(0);
         availRegs.take(ArgumentsRectifierReg);
         availRegs.take(code);
         emitProfilingUpdate(masm, availRegs, ICCall_ScriptedFunCall::offsetOfPCOffset());
     }
 
-    masm.callIon(code);
+    masm.callJit(code);
 
     leaveStubFrame(masm, true);
 
     // Enter type monitor IC to type-check result.
     EmitEnterTypeMonitorIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
--- a/js/src/jit/BaselineInspector.h
+++ b/js/src/jit/BaselineInspector.h
@@ -87,17 +87,17 @@ class BaselineInspector
         }
         return ICInspectorType(this, pc, ent);
     }
 
     ICStub *monomorphicStub(jsbytecode *pc);
     bool dimorphicStub(jsbytecode *pc, ICStub **pfirst, ICStub **psecond);
 
   public:
-    typedef Vector<Shape *, 4, IonAllocPolicy> ShapeVector;
+    typedef Vector<Shape *, 4, JitAllocPolicy> ShapeVector;
     bool maybeShapesForPropertyOp(jsbytecode *pc, ShapeVector &shapes);
 
     SetElemICInspector setElemICInspector(jsbytecode *pc) {
         return makeICInspector<SetElemICInspector>(pc, ICStub::SetElem_Fallback);
     }
 
     MIRType expectedResultType(jsbytecode *pc);
     MCompare::CompareType expectedCompareType(jsbytecode *pc);
--- a/js/src/jit/BaselineJIT.cpp
+++ b/js/src/jit/BaselineJIT.cpp
@@ -17,17 +17,17 @@
 #include "vm/Interpreter.h"
 #include "vm/TraceLogging.h"
 
 #include "jsgcinlines.h"
 #include "jsobjinlines.h"
 #include "jsopcodeinlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 /* static */ PCMappingSlotInfo::SlotLocation
 PCMappingSlotInfo::ToSlotLocation(const StackValue *stackVal)
 {
@@ -73,27 +73,27 @@ CheckFrame(InterpreterFrame *fp)
         // Fall back to the interpreter to avoid running out of stack space.
         JitSpew(JitSpew_BaselineAbort, "Too many arguments (%u)", fp->numActualArgs());
         return false;
     }
 
     return true;
 }
 
-static IonExecStatus
+static JitExecStatus
 EnterBaseline(JSContext *cx, EnterJitData &data)
 {
     if (data.osrFrame) {
         // Check for potential stack overflow before OSR-ing.
         uint8_t spDummy;
         uint32_t extra = BaselineFrame::Size() + (data.osrNumStackValues * sizeof(Value));
         uint8_t *checkSp = (&spDummy) - extra;
-        JS_CHECK_RECURSION_WITH_SP(cx, checkSp, return IonExec_Aborted);
+        JS_CHECK_RECURSION_WITH_SP(cx, checkSp, return JitExec_Aborted);
     } else {
-        JS_CHECK_RECURSION(cx, return IonExec_Aborted);
+        JS_CHECK_RECURSION(cx, return JitExec_Aborted);
     }
 
     MOZ_ASSERT(jit::IsBaselineEnabled(cx));
     MOZ_ASSERT_IF(data.osrFrame, CheckFrame(data.osrFrame));
 
     EnterJitCode enter = cx->runtime()->jitRuntime()->enterBaseline();
 
     // Caller must construct |this| before invoking the Ion function.
@@ -120,40 +120,40 @@ EnterBaseline(JSContext *cx, EnterJitDat
     // Jit callers wrap primitive constructor return.
     if (!data.result.isMagic() && data.constructing && data.result.isPrimitive())
         data.result = data.maxArgv[0];
 
     // Release temporary buffer used for OSR into Ion.
     cx->runtime()->getJitRuntime(cx)->freeOsrTempData();
 
     MOZ_ASSERT_IF(data.result.isMagic(), data.result.isMagic(JS_ION_ERROR));
-    return data.result.isMagic() ? IonExec_Error : IonExec_Ok;
+    return data.result.isMagic() ? JitExec_Error : JitExec_Ok;
 }
 
-IonExecStatus
+JitExecStatus
 jit::EnterBaselineMethod(JSContext *cx, RunState &state)
 {
     BaselineScript *baseline = state.script()->baselineScript();
 
     EnterJitData data(cx);
     data.jitcode = baseline->method()->raw();
 
     AutoValueVector vals(cx);
     if (!SetEnterJitData(cx, data, state, vals))
-        return IonExec_Error;
+        return JitExec_Error;
 
-    IonExecStatus status = EnterBaseline(cx, data);
-    if (status != IonExec_Ok)
+    JitExecStatus status = EnterBaseline(cx, data);
+    if (status != JitExec_Ok)
         return status;
 
     state.setReturnValue(data.result);
-    return IonExec_Ok;
+    return JitExec_Ok;
 }
 
-IonExecStatus
+JitExecStatus
 jit::EnterBaselineAtBranch(JSContext *cx, InterpreterFrame *fp, jsbytecode *pc)
 {
     MOZ_ASSERT(JSOp(*pc) == JSOP_LOOPENTRY);
 
     BaselineScript *baseline = fp->script()->baselineScript();
 
     EnterJitData data(cx);
     data.jitcode = baseline->nativeCodeForPC(fp->script(), pc);
@@ -191,39 +191,39 @@ jit::EnterBaselineAtBranch(JSContext *cx
         else
             data.calleeToken = CalleeToToken(fp->script());
     }
 
     TraceLogger *logger = TraceLoggerForMainThread(cx->runtime());
     TraceLogStopEvent(logger, TraceLogger::Interpreter);
     TraceLogStartEvent(logger, TraceLogger::Baseline);
 
-    IonExecStatus status = EnterBaseline(cx, data);
-    if (status != IonExec_Ok)
+    JitExecStatus status = EnterBaseline(cx, data);
+    if (status != JitExec_Ok)
         return status;
 
     fp->setReturnValue(data.result);
-    return IonExec_Ok;
+    return JitExec_Ok;
 }
 
 MethodStatus
 jit::BaselineCompile(JSContext *cx, JSScript *script, bool forceDebugInstrumentation)
 {
     MOZ_ASSERT(!script->hasBaselineScript());
     MOZ_ASSERT(script->canBaselineCompile());
     MOZ_ASSERT(IsBaselineEnabled(cx));
 
     script->ensureNonLazyCanonicalFunction(cx);
 
     LifoAlloc alloc(TempAllocator::PreferredLifoChunkSize);
     TempAllocator *temp = alloc.new_<TempAllocator>(&alloc);
     if (!temp)
         return Method_Error;
 
-    IonContext ictx(cx, temp);
+    JitContext jctx(cx, temp);
 
     BaselineCompiler compiler(cx, *temp, script);
     if (!compiler.init())
         return Method_Error;
     if (forceDebugInstrumentation)
         compiler.setCompileDebugInstrumentation();
 
     MethodStatus status = compiler.compile();
--- a/js/src/jit/BaselineJIT.h
+++ b/js/src/jit/BaselineJIT.h
@@ -10,17 +10,17 @@
 #include "mozilla/MemoryReporting.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "ds/LifoAlloc.h"
 #include "jit/Bailouts.h"
 #include "jit/IonCode.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 class StackValue;
 class ICEntry;
 class ICStub;
 
@@ -410,20 +410,20 @@ IsBaselineEnabled(JSContext *cx)
 }
 
 MethodStatus
 CanEnterBaselineMethod(JSContext *cx, RunState &state);
 
 MethodStatus
 CanEnterBaselineAtBranch(JSContext *cx, InterpreterFrame *fp, bool newType);
 
-IonExecStatus
+JitExecStatus
 EnterBaselineMethod(JSContext *cx, RunState &state);
 
-IonExecStatus
+JitExecStatus
 EnterBaselineAtBranch(JSContext *cx, InterpreterFrame *fp, jsbytecode *pc);
 
 void
 FinishDiscardBaselineScript(FreeOp *fop, JSScript *script);
 
 void
 AddSizeOfBaselineData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf, size_t *data,
                       size_t *fallbackStubs);
--- a/js/src/jit/BitSet.h
+++ b/js/src/jit/BitSet.h
@@ -4,17 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_BitSet_h
 #define jit_BitSet_h
 
 #include "mozilla/MathAlgorithms.h"
 
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 
 namespace js {
 namespace jit {
 
 // Provides constant time set insertion and removal, and fast linear
 // set operations such as intersection, difference, and union.
 // N.B. All set operations must be performed on sets with the same number
 // of bits.
--- a/js/src/jit/BytecodeAnalysis.cpp
+++ b/js/src/jit/BytecodeAnalysis.cpp
@@ -46,17 +46,17 @@ BytecodeAnalysis::init(TempAllocator &al
         return false;
 
     jsbytecode *end = script_->codeEnd();
 
     // Clear all BytecodeInfo.
     mozilla::PodZero(infos_.begin(), infos_.length());
     infos_[0].init(/*stackDepth=*/0);
 
-    Vector<CatchFinallyRange, 0, IonAllocPolicy> catchFinallyRanges(alloc);
+    Vector<CatchFinallyRange, 0, JitAllocPolicy> catchFinallyRanges(alloc);
 
     jsbytecode *nextpc;
     for (jsbytecode *pc = script_->code(); pc < end; pc = nextpc) {
         JSOp op = JSOp(*pc);
         nextpc = pc + GetBytecodeLength(pc);
         unsigned offset = script_->pcToOffset(pc);
 
         JitSpew(JitSpew_BaselineOp, "Analyzing op @ %d (end=%d): %s",
--- a/js/src/jit/BytecodeAnalysis.h
+++ b/js/src/jit/BytecodeAnalysis.h
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_BytecodeAnalysis_h
 #define jit_BytecodeAnalysis_h
 
 #include "jsscript.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "js/Vector.h"
 
 namespace js {
 namespace jit {
 
 // Basic information about bytecodes in the script.  Used to help baseline compilation.
 struct BytecodeInfo
 {
@@ -31,17 +31,17 @@ struct BytecodeInfo
         initialized = true;
         stackDepth = depth;
     }
 };
 
 class BytecodeAnalysis
 {
     JSScript *script_;
-    Vector<BytecodeInfo, 0, IonAllocPolicy> infos_;
+    Vector<BytecodeInfo, 0, JitAllocPolicy> infos_;
 
     bool usesScopeChain_;
     bool hasTryFinally_;
     bool hasSetArg_;
 
   public:
     explicit BytecodeAnalysis(TempAllocator &alloc, JSScript *script);
 
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -21,20 +21,20 @@
 #include "builtin/TypedObject.h"
 #ifdef JSGC_GENERATIONAL
 # include "gc/Nursery.h"
 #endif
 #include "irregexp/NativeRegExpMacroAssembler.h"
 #include "jit/BaselineCompiler.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonCaches.h"
-#include "jit/IonLinker.h"
 #include "jit/IonOptimizationLevels.h"
 #include "jit/JitcodeMap.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #include "jit/Lowering.h"
 #include "jit/MIRGenerator.h"
 #include "jit/MoveEmitter.h"
 #include "jit/ParallelFunctions.h"
 #include "jit/ParallelSafetyAnalysis.h"
 #include "jit/RangeAnalysis.h"
 #include "vm/ForkJoin.h"
 #include "vm/MatchPairs.h"
@@ -677,17 +677,17 @@ CodeGenerator::getJumpLabelForBranch(MBa
     if (!labelForBackedgeWithImplicitCheck(block))
         return block->lir()->label();
 
     // We need to use a patchable jump for this backedge, but want to treat
     // this as a normal label target to simplify codegen. Efficiency isn't so
     // important here as these tests are extremely unlikely to be used in loop
     // backedges, so emit inline code for the patchable jump. Heap allocating
     // the label allows it to be used by out of line blocks.
-    Label *res = GetIonContext()->temp->lifoAlloc()->new_<Label>();
+    Label *res = GetJitContext()->temp->lifoAlloc()->new_<Label>();
     Label after;
     masm.jump(&after);
     masm.bind(res);
     jumpToBlock(block);
     masm.bind(&after);
     return res;
 }
 
@@ -823,17 +823,17 @@ CodeGenerator::visitTypeObjectDispatch(L
     return true;
 }
 
 bool
 CodeGenerator::visitBooleanToString(LBooleanToString *lir)
 {
     Register input = ToRegister(lir->input());
     Register output = ToRegister(lir->output());
-    const JSAtomState &names = GetIonContext()->runtime->names();
+    const JSAtomState &names = GetJitContext()->runtime->names();
     Label true_, done;
 
     masm.branchTest32(Assembler::NonZero, input, input, &true_);
     masm.movePtr(ImmGCPtr(names.false_), output);
     masm.jump(&done);
 
     masm.bind(&true_);
     masm.movePtr(ImmGCPtr(names.true_), output);
@@ -844,17 +844,17 @@ CodeGenerator::visitBooleanToString(LBoo
 }
 
 void
 CodeGenerator::emitIntToString(Register input, Register output, Label *ool)
 {
     masm.branch32(Assembler::AboveOrEqual, input, Imm32(StaticStrings::INT_STATIC_LIMIT), ool);
 
     // Fast path for small integers.
-    masm.movePtr(ImmPtr(&GetIonContext()->runtime->staticStrings().intStaticTable), output);
+    masm.movePtr(ImmPtr(&GetJitContext()->runtime->staticStrings().intStaticTable), output);
     masm.loadPtr(BaseIndex(output, input, ScalePointer), output);
 }
 
 typedef JSFlatString *(*IntToStringFn)(ThreadSafeContext *, int);
 typedef JSFlatString *(*IntToStringParFn)(ForkJoinContext *, int);
 static const VMFunctionsModal IntToStringInfo = VMFunctionsModal(
     FunctionInfo<IntToStringFn>(Int32ToString<CanGC>),
     FunctionInfo<IntToStringParFn>(IntToStringPar));
@@ -916,17 +916,17 @@ CodeGenerator::visitValueToString(LValue
 
     OutOfLineCode *ool = oolCallVM(PrimitiveToStringInfo, lir, (ArgList(), input),
                                    StoreRegisterTo(output));
     if (!ool)
         return false;
 
     Label done;
     Register tag = masm.splitTagForTest(input);
-    const JSAtomState &names = GetIonContext()->runtime->names();
+    const JSAtomState &names = GetJitContext()->runtime->names();
 
     // String
     if (lir->mir()->input()->mightBeType(MIRType_String)) {
         Label notString;
         masm.branchTestString(Assembler::NotEqual, tag, &notString);
         masm.unboxString(input, output);
         masm.jump(&done);
         masm.bind(&notString);
@@ -2035,27 +2035,27 @@ CodeGenerator::visitParameter(LParameter
 {
     return true;
 }
 
 bool
 CodeGenerator::visitCallee(LCallee *lir)
 {
     Register callee = ToRegister(lir->output());
-    Address ptr(StackPointer, frameSize() + IonJSFrameLayout::offsetOfCalleeToken());
+    Address ptr(StackPointer, frameSize() + JitFrameLayout::offsetOfCalleeToken());
 
     masm.loadFunctionFromCalleeToken(ptr, callee);
     return true;
 }
 
 bool
 CodeGenerator::visitIsConstructing(LIsConstructing *lir)
 {
     Register output = ToRegister(lir->output());
-    Address calleeToken(StackPointer, frameSize() + IonJSFrameLayout::offsetOfCalleeToken());
+    Address calleeToken(StackPointer, frameSize() + JitFrameLayout::offsetOfCalleeToken());
     masm.loadPtr(calleeToken, output);
 
     // We must be inside a function.
     MOZ_ASSERT(current->mir()->info().script()->functionNonDelazifying());
 
     // The low bit indicates whether this call is constructing, just clear the
     // other bits.
     static_assert(CalleeToken_Function == 0x0, "CalleeTokenTag value should match");
@@ -2706,17 +2706,17 @@ CodeGenerator::visitOutOfLineCallPostWri
         objreg = regs.takeAny();
         masm.movePtr(ImmGCPtr(object), objreg);
     } else {
         objreg = ToRegister(obj);
         regs.takeUnchecked(objreg);
     }
 
     Register runtimereg = regs.takeAny();
-    masm.mov(ImmPtr(GetIonContext()->runtime), runtimereg);
+    masm.mov(ImmPtr(GetJitContext()->runtime), runtimereg);
 
     void (*fun)(JSRuntime*, JSObject*) = isGlobal ? PostGlobalWriteBarrier : PostWriteBarrier;
     masm.setupUnalignedABICall(2, regs.takeAny());
     masm.passABIArg(runtimereg);
     masm.passABIArg(objreg);
     masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, fun));
 
     restoreLiveVolatile(ool->lir());
@@ -2827,17 +2827,17 @@ CodeGenerator::visitCallNative(LCallNati
 
     masm.Push(argUintNReg);
 
     // Construct native exit frame.
     uint32_t safepointOffset;
     if (!masm.buildFakeExitFrame(tempReg, &safepointOffset))
         return false;
     masm.enterFakeExitFrame(argContextReg, tempReg, executionMode,
-                            IonNativeExitFrameLayout::Token());
+                            NativeExitFrameLayout::Token());
 
     if (!markSafepointAt(safepointOffset, call))
         return false;
 
     // Construct and execute call.
     masm.setupUnalignedABICall(3, tempReg);
     masm.passABIArg(argContextReg);
     masm.passABIArg(argUintNReg);
@@ -2855,23 +2855,23 @@ CodeGenerator::visitCallNative(LCallNati
       default:
         MOZ_CRASH("No such execution mode");
     }
 
     // Test for failure.
     masm.branchIfFalseBool(ReturnReg, masm.failureLabel(executionMode));
 
     // Load the outparam vp[0] into output register(s).
-    masm.loadValue(Address(StackPointer, IonNativeExitFrameLayout::offsetOfResult()), JSReturnOperand);
+    masm.loadValue(Address(StackPointer, NativeExitFrameLayout::offsetOfResult()), JSReturnOperand);
 
     // The next instruction is removing the footer of the exit frame, so there
     // is no need for leaveFakeExitFrame.
 
     // Move the StackPointer back to its original location, unwinding the native exit frame.
-    masm.adjustStack(IonNativeExitFrameLayout::Size() - unusedStack);
+    masm.adjustStack(NativeExitFrameLayout::Size() - unusedStack);
     MOZ_ASSERT(masm.framePushed() == initialStack);
 
     dropArguments(call->numStackArgs() + 1);
     return true;
 }
 
 static void
 LoadDOMPrivate(MacroAssembler &masm, Register obj, Register priv)
@@ -3096,23 +3096,23 @@ CodeGenerator::visitCallGeneric(LCallGen
         MOZ_ASSERT(ArgumentsRectifierReg != objreg);
         masm.movePtr(ImmGCPtr(argumentsRectifier), objreg); // Necessary for GC marking.
         masm.loadPtr(Address(objreg, JitCode::offsetOfCode()), objreg);
         masm.move32(Imm32(call->numStackArgs()), ArgumentsRectifierReg);
     }
 
     // Finally call the function in objreg.
     masm.bind(&makeCall);
-    uint32_t callOffset = masm.callIon(objreg);
+    uint32_t callOffset = masm.callJit(objreg);
     if (!markSafepointAt(callOffset, call))
         return false;
 
     // Increment to remove IonFramePrefix; decrement to fill FrameSizeClass.
     // The return address has already been removed from the Ion frame.
-    int prefixGarbage = sizeof(IonJSFrameLayout) - sizeof(void *);
+    int prefixGarbage = sizeof(JitFrameLayout) - sizeof(void *);
     masm.adjustStack(prefixGarbage - unusedStack);
     masm.jump(&end);
 
     // Handle uncompiled or native functions.
     masm.bind(&invoke);
     switch (executionMode) {
       case SequentialExecution:
         if (!emitCallInvokeFunction(call, calleereg, call->numActualArgs(), unusedStack))
@@ -3196,23 +3196,23 @@ CodeGenerator::visitCallKnown(LCallKnown
 
     // Construct the IonFramePrefix.
     uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), JitFrame_IonJS);
     masm.Push(Imm32(call->numActualArgs()));
     masm.PushCalleeToken(calleereg, call->mir()->isConstructing());
     masm.Push(Imm32(descriptor));
 
     // Finally call the function in objreg.
-    uint32_t callOffset = masm.callIon(objreg);
+    uint32_t callOffset = masm.callJit(objreg);
     if (!markSafepointAt(callOffset, call))
         return false;
 
     // Increment to remove IonFramePrefix; decrement to fill FrameSizeClass.
     // The return address has already been removed from the Ion frame.
-    int prefixGarbage = sizeof(IonJSFrameLayout) - sizeof(void *);
+    int prefixGarbage = sizeof(JitFrameLayout) - sizeof(void *);
     masm.adjustStack(prefixGarbage - unusedStack);
     masm.jump(&end);
 
     // Handle uncompiled functions.
     masm.bind(&uncompiled);
     switch (executionMode) {
       case SequentialExecution:
         if (!emitCallInvokeFunction(call, calleereg, call->numActualArgs(), unusedStack))
@@ -3269,17 +3269,17 @@ CodeGenerator::emitCallInvokeFunction(LA
 // correspond to what is expected by the snapshots.
 void
 CodeGenerator::emitPushArguments(LApplyArgsGeneric *apply, Register extraStackSpace)
 {
     // Holds the function nargs. Initially undefined.
     Register argcreg = ToRegister(apply->getArgc());
 
     Register copyreg = ToRegister(apply->getTempObject());
-    size_t argvOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs();
+    size_t argvOffset = frameSize() + JitFrameLayout::offsetOfActualArgs();
     Label end;
 
     // Initialize the loop counter AND Compute the stack usage (if == 0)
     masm.movePtr(argcreg, extraStackSpace);
     masm.branchTestPtr(Assembler::Zero, argcreg, argcreg, &end);
 
     // Copy arguments.
     {
@@ -3417,28 +3417,28 @@ CodeGenerator::visitApplyArgsGeneric(LAp
             masm.movePtr(ImmGCPtr(argumentsRectifier), objreg); // Necessary for GC marking.
             masm.loadPtr(Address(objreg, JitCode::offsetOfCode()), objreg);
             masm.movePtr(argcreg, ArgumentsRectifierReg);
         }
 
         masm.bind(&rejoin);
 
         // Finally call the function in objreg, as assigned by one of the paths above.
-        uint32_t callOffset = masm.callIon(objreg);
+        uint32_t callOffset = masm.callJit(objreg);
         if (!markSafepointAt(callOffset, apply))
             return false;
 
         // Recover the number of arguments from the frame descriptor.
         masm.loadPtr(Address(StackPointer, 0), copyreg);
         masm.rshiftPtr(Imm32(FRAMESIZE_SHIFT), copyreg);
         masm.subPtr(Imm32(pushed), copyreg);
 
         // Increment to remove IonFramePrefix; decrement to fill FrameSizeClass.
         // The return address has already been removed from the Ion frame.
-        int prefixGarbage = sizeof(IonJSFrameLayout) - sizeof(void *);
+        int prefixGarbage = sizeof(JitFrameLayout) - sizeof(void *);
         masm.adjustStack(prefixGarbage);
         masm.jump(&end);
     }
 
     // Handle uncompiled or native functions.
     {
         masm.bind(&invoke);
         if (!emitCallInvokeFunction(apply, copyreg))
@@ -3672,17 +3672,17 @@ CodeGenerator::visitCheckOverRecursed(LC
     // crossed, an error must be thrown, which requires more frames.
     //
     // It must always be possible to trespass past the stack limit.
     // Ion may legally place frames very close to the limit. Calling additional
     // C functions may then violate the limit without any checking.
 
     // Since Ion frames exist on the C stack, the stack limit may be
     // dynamically set by JS_SetThreadStackLimit() and JS_SetNativeStackQuota().
-    const void *limitAddr = GetIonContext()->runtime->addressOfJitStackLimit();
+    const void *limitAddr = GetJitContext()->runtime->addressOfJitStackLimit();
 
     CheckOverRecursedFailure *ool = new(alloc()) CheckOverRecursedFailure(lir);
     if (!addOutOfLineCode(ool, lir->mir()))
         return false;
 
     // Conditional forward (unlikely) branch to failure.
     masm.branchPtr(Assembler::AboveOrEqual, AbsoluteAddress(limitAddr), StackPointer, ool->entry());
     masm.bind(ool->rejoin());
@@ -3792,17 +3792,17 @@ CodeGenerator::visitInterruptCheckPar(LI
 }
 
 IonScriptCounts *
 CodeGenerator::maybeCreateScriptCounts()
 {
     // If scripts are being profiled, create a new IonScriptCounts for the
     // profiling data, which will be attached to the associated JSScript or
     // AsmJS module after code generation finishes.
-    if (!GetIonContext()->runtime->profilingScripts())
+    if (!GetJitContext()->runtime->profilingScripts())
         return nullptr;
 
     IonScriptCounts *counts = nullptr;
 
     CompileInfo *outerInfo = &gen->info();
     JSScript *script = outerInfo->script();
 
     counts = js_new<IonScriptCounts>();
@@ -3855,17 +3855,17 @@ struct ScriptCountBlockState
 {
     IonBlockCounts &block;
     MacroAssembler &masm;
 
     Sprinter printer;
 
   public:
     ScriptCountBlockState(IonBlockCounts *block, MacroAssembler *masm)
-      : block(*block), masm(*masm), printer(GetIonContext()->cx)
+      : block(*block), masm(*masm), printer(GetJitContext()->cx)
     {
     }
 
     bool init()
     {
         if (!printer.init())
             return false;
 
@@ -4970,17 +4970,17 @@ CodeGenerator::visitCreateThisWithTempla
     masm.bind(ool->rejoin());
 
     bool initFixedSlots = ShouldInitFixedSlots(lir, templateObject);
     masm.initGCThing(objReg, tempReg, templateObject, initFixedSlots);
 
     return true;
 }
 
-typedef JSObject *(*NewIonArgumentsObjectFn)(JSContext *cx, IonJSFrameLayout *frame, HandleObject);
+typedef JSObject *(*NewIonArgumentsObjectFn)(JSContext *cx, JitFrameLayout *frame, HandleObject);
 static const VMFunction NewIonArgumentsObjectInfo =
     FunctionInfo<NewIonArgumentsObjectFn>((NewIonArgumentsObjectFn) ArgumentsObject::createForIon);
 
 bool
 CodeGenerator::visitCreateArgumentsObject(LCreateArgumentsObject *lir)
 {
     // This should be getting constructed in the first block only, and not any OSR entry blocks.
     MOZ_ASSERT(lir->mir()->block()->id() == 0);
@@ -6085,17 +6085,17 @@ bool CodeGenerator::visitSubstr(LSubstr 
                                     StoreRegisterTo(output));
     if (!ool)
         return false;
     Label *slowPath = ool->entry();
     Label *done = ool->rejoin();
 
     // Zero length, return emptystring.
     masm.branchTest32(Assembler::NonZero, length, length, &nonZero);
-    const JSAtomState &names = GetIonContext()->runtime->names();
+    const JSAtomState &names = GetJitContext()->runtime->names();
     masm.movePtr(ImmGCPtr(names.empty), output);
     masm.jump(done);
 
     // Use slow path for ropes.
     masm.bind(&nonZero);
     static_assert(JSString::ROPE_FLAGS == 0,
                   "rope flags must be zero for (flags & TYPE_FLAGS_MASK) == 0 "
                   "to be a valid is-rope check");
@@ -6399,17 +6399,17 @@ JitRuntime::generateLazyLinkStub(JSConte
         masm.push(lr);
 #endif
     masm.enterExitFrame();
     masm.setupUnalignedABICall(1, temp0);
     masm.loadJSContext(temp0);
     masm.passABIArg(temp0);
     masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, LazyLinkTopActivation));
     masm.leaveExitFrame();
-    masm.retn(Imm32(sizeof(IonExitFrameLayout)));
+    masm.retn(Imm32(sizeof(ExitFrameLayout)));
 
     Linker linker(masm);
     AutoFlushICache afc("LazyLinkStub");
     JitCode *code = linker.newCode<NoGC>(cx, OTHER_CODE);
 
 #ifdef JS_ION_PERF
     writePerfSpewerJitCodeProfile(code, "LazyLinkStub");
 #endif
@@ -6449,17 +6449,17 @@ CodeGenerator::visitFromCharCode(LFromCh
     OutOfLineCode *ool = oolCallVM(StringFromCharCodeInfo, lir, (ArgList(), code), StoreRegisterTo(output));
     if (!ool)
         return false;
 
     // OOL path if code >= UNIT_STATIC_LIMIT.
     masm.branch32(Assembler::AboveOrEqual, code, Imm32(StaticStrings::UNIT_STATIC_LIMIT),
                   ool->entry());
 
-    masm.movePtr(ImmPtr(&GetIonContext()->runtime->staticStrings().unitStaticTable), output);
+    masm.movePtr(ImmPtr(&GetJitContext()->runtime->staticStrings().unitStaticTable), output);
     masm.loadPtr(BaseIndex(output, code, ScalePointer), output);
 
     masm.bind(ool->rejoin());
     return true;
 }
 
 typedef JSObject *(*StringSplitFn)(JSContext *, HandleTypeObject, HandleString, HandleString);
 static const VMFunction StringSplitInfo = FunctionInfo<StringSplitFn>(js::str_split_string);
@@ -7217,17 +7217,17 @@ CodeGenerator::visitIteratorStart(LItera
     const Register temp1 = ToRegister(lir->temp1());
     const Register temp2 = ToRegister(lir->temp2());
     const Register niTemp = ToRegister(lir->temp3()); // Holds the NativeIterator object.
 
     // Iterators other than for-in should use LCallIteratorStart.
     MOZ_ASSERT(flags == JSITER_ENUMERATE);
 
     // Fetch the most recent iterator and ensure it's not nullptr.
-    masm.loadPtr(AbsoluteAddress(GetIonContext()->runtime->addressOfLastCachedNativeIterator()), output);
+    masm.loadPtr(AbsoluteAddress(GetJitContext()->runtime->addressOfLastCachedNativeIterator()), output);
     masm.branchTestPtr(Assembler::Zero, output, output, ool->entry());
 
     // Load NativeIterator.
     masm.loadObjPrivate(output, JSObject::ITER_CLASS_NFIXED_SLOTS, niTemp);
 
     // Ensure the |active| and |unreusable| bits are not set.
     masm.branchTest32(Assembler::NonZero, Address(niTemp, offsetof(NativeIterator, flags)),
                       Imm32(JSITER_ACTIVE|JSITER_UNREUSABLE), ool->entry());
@@ -7415,45 +7415,45 @@ CodeGenerator::visitIteratorEnd(LIterato
     return true;
 }
 
 bool
 CodeGenerator::visitArgumentsLength(LArgumentsLength *lir)
 {
     // read number of actual arguments from the JS frame.
     Register argc = ToRegister(lir->output());
-    Address ptr(StackPointer, frameSize() + IonJSFrameLayout::offsetOfNumActualArgs());
+    Address ptr(StackPointer, frameSize() + JitFrameLayout::offsetOfNumActualArgs());
 
     masm.loadPtr(ptr, argc);
     return true;
 }
 
 bool
 CodeGenerator::visitGetFrameArgument(LGetFrameArgument *lir)
 {
     ValueOperand result = GetValueOutput(lir);
     const LAllocation *index = lir->index();
-    size_t argvOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs();
+    size_t argvOffset = frameSize() + JitFrameLayout::offsetOfActualArgs();
 
     if (index->isConstant()) {
         int32_t i = index->toConstant()->toInt32();
         Address argPtr(StackPointer, sizeof(Value) * i + argvOffset);
         masm.loadValue(argPtr, result);
     } else {
         Register i = ToRegister(index);
         BaseValueIndex argPtr(StackPointer, i, argvOffset);
         masm.loadValue(argPtr, result);
     }
     return true;
 }
 
 bool
 CodeGenerator::visitSetFrameArgumentT(LSetFrameArgumentT *lir)
 {
-    size_t argOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs() +
+    size_t argOffset = frameSize() + JitFrameLayout::offsetOfActualArgs() +
                        (sizeof(Value) * lir->mir()->argno());
 
     MIRType type = lir->mir()->value()->type();
 
     if (type == MIRType_Double) {
         // Store doubles directly.
         FloatRegister input = ToFloatRegister(lir->input());
         masm.storeDouble(input, Address(StackPointer, argOffset));
@@ -7463,27 +7463,27 @@ CodeGenerator::visitSetFrameArgumentT(LS
         masm.storeValue(ValueTypeFromMIRType(type), input, Address(StackPointer, argOffset));
     }
     return true;
 }
 
 bool
 CodeGenerator:: visitSetFrameArgumentC(LSetFrameArgumentC *lir)
 {
-    size_t argOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs() +
+    size_t argOffset = frameSize() + JitFrameLayout::offsetOfActualArgs() +
                        (sizeof(Value) * lir->mir()->argno());
     masm.storeValue(lir->val(), Address(StackPointer, argOffset));
     return true;
 }
 
 bool
 CodeGenerator:: visitSetFrameArgumentV(LSetFrameArgumentV *lir)
 {
     const ValueOperand val = ToValue(lir, LSetFrameArgumentV::Input);
-    size_t argOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs() +
+    size_t argOffset = frameSize() + JitFrameLayout::offsetOfActualArgs() +
                        (sizeof(Value) * lir->mir()->argno());
     masm.storeValue(val, Address(StackPointer, argOffset));
     return true;
 }
 
 typedef bool (*RunOnceScriptPrologueFn)(JSContext *, HandleScript);
 static const VMFunction RunOnceScriptPrologueInfo =
     FunctionInfo<RunOnceScriptPrologueFn>(js::RunOnceScriptPrologue);
@@ -7505,17 +7505,17 @@ static const VMFunctionsModal InitRestPa
     FunctionInfo<InitRestParameterParFn>(InitRestParameterPar));
 
 bool
 CodeGenerator::emitRest(LInstruction *lir, Register array, Register numActuals,
                         Register temp0, Register temp1, unsigned numFormals,
                         JSObject *templateObject, bool saveAndRestore, Register resultreg)
 {
     // Compute actuals() + numFormals.
-    size_t actualsOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs();
+    size_t actualsOffset = frameSize() + JitFrameLayout::offsetOfActualArgs();
     masm.movePtr(StackPointer, temp1);
     masm.addPtr(Imm32(sizeof(Value) * numFormals + actualsOffset), temp1);
 
     // Compute numActuals - numFormals.
     Label emptyLength, joinLength;
     masm.movePtr(numActuals, temp0);
     masm.branch32(Assembler::LessThanOrEqual, temp0, Imm32(numFormals), &emptyLength);
     masm.sub32(Imm32(numFormals), temp0);
@@ -8820,17 +8820,17 @@ class OutOfLineTypeOfV : public OutOfLin
 
 bool
 CodeGenerator::visitTypeOfV(LTypeOfV *lir)
 {
     const ValueOperand value = ToValue(lir, LTypeOfV::Input);
     Register output = ToRegister(lir->output());
     Register tag = masm.splitTagForTest(value);
 
-    const JSAtomState &names = GetIonContext()->runtime->names();
+    const JSAtomState &names = GetJitContext()->runtime->names();
     Label done;
 
     MDefinition *input = lir->mir()->input();
 
     bool testObject = input->mightBeType(MIRType_Object);
     bool testNumber = input->mightBeType(MIRType_Int32) || input->mightBeType(MIRType_Double);
     bool testBoolean = input->mightBeType(MIRType_Boolean);
     bool testUndefined = input->mightBeType(MIRType_Undefined);
@@ -8953,17 +8953,17 @@ CodeGenerator::visitOutOfLineTypeOfV(Out
     Register temp = ToTempUnboxRegister(ins->tempToUnbox());
     Register output = ToRegister(ins->output());
 
     Register obj = masm.extractObject(input, temp);
 
     saveVolatile(output);
     masm.setupUnalignedABICall(2, output);
     masm.passABIArg(obj);
-    masm.movePtr(ImmPtr(GetIonContext()->runtime), output);
+    masm.movePtr(ImmPtr(GetJitContext()->runtime), output);
     masm.passABIArg(output);
     masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, js::TypeOfObjectOperation));
     masm.storeCallResult(output);
     restoreVolatile(output);
 
     masm.jump(ool->rejoin());
     return true;
 }
@@ -10184,17 +10184,17 @@ CodeGenerator::visitAssertRangeV(LAssert
 
 bool
 CodeGenerator::visitInterruptCheck(LInterruptCheck *lir)
 {
     OutOfLineCode *ool = oolCallVM(InterruptCheckInfo, lir, (ArgList()), StoreNothing());
     if (!ool)
         return false;
 
-    AbsoluteAddress interruptAddr(GetIonContext()->runtime->addressOfInterruptUint32());
+    AbsoluteAddress interruptAddr(GetJitContext()->runtime->addressOfInterruptUint32());
     masm.branch32(Assembler::NotEqual, interruptAddr, Imm32(0), ool->entry());
     masm.bind(ool->rejoin());
     return true;
 }
 
 bool
 CodeGenerator::visitAsmJSInterruptCheck(LAsmJSInterruptCheck *lir)
 {
--- a/js/src/jit/CodeGenerator.h
+++ b/js/src/jit/CodeGenerator.h
@@ -476,17 +476,17 @@ class CodeGenerator : public CodeGenerat
 
     // Bailout if an element about to be written to is a hole.
     bool emitStoreHoleCheck(Register elements, const LAllocation *index, int32_t offsetAdjustment,
                             LSnapshot *snapshot);
 
     bool emitAssertRangeI(const Range *r, Register input);
     bool emitAssertRangeD(const Range *r, FloatRegister input, FloatRegister temp);
 
-    Vector<CodeOffsetLabel, 0, IonAllocPolicy> ionScriptLabels_;
+    Vector<CodeOffsetLabel, 0, JitAllocPolicy> ionScriptLabels_;
 #ifdef DEBUG
     bool branchIfInvalidated(Register temp, Label *invalidated);
 
     bool emitDebugResultChecks(LInstruction *ins);
     bool emitObjectOrStringResultChecks(LInstruction *lir, MDefinition *mir);
     bool emitValueResultChecks(LInstruction *lir, MDefinition *mir);
 #endif
 
--- a/js/src/jit/CompileInfo-inl.h
+++ b/js/src/jit/CompileInfo-inl.h
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_CompileInfo_inl_h
 #define jit_CompileInfo_inl_h
 
 #include "jit/CompileInfo.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 
 #include "jsscriptinlines.h"
 
 namespace js {
 namespace jit {
 
 inline RegExpObject *
 CompileInfo::getRegExp(jsbytecode *pc) const
--- a/js/src/jit/CompileInfo.h
+++ b/js/src/jit/CompileInfo.h
@@ -4,17 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_CompileInfo_h
 #define jit_CompileInfo_h
 
 #include "jsfun.h"
 
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/Registers.h"
 #include "vm/ScopeObject.h"
 
 namespace js {
 namespace jit {
 
 inline unsigned
 StartArgSlot(JSScript *script)
--- a/js/src/jit/CompileWrappers.h
+++ b/js/src/jit/CompileWrappers.h
@@ -32,23 +32,23 @@ class CompileRuntime
     js::PerThreadData *mainThread();
 
     // &mainThread.jitTop
     const void *addressOfJitTop();
 
     // rt->mainThread.jitStackLimit;
     const void *addressOfJitStackLimit();
 
-    // &mainThread.ionJSContext
+    // &mainThread.jitJSContext
     const void *addressOfJSContext();
 
     // &mainThread.activation_
     const void *addressOfActivation();
 
-    // &GetIonContext()->runtime->nativeIterCache.last
+    // &GetJitContext()->runtime->nativeIterCache.last
     const void *addressOfLastCachedNativeIterator();
 
 #ifdef JS_GC_ZEAL
     const void *addressOfGCZeal();
 #endif
 
     const void *addressOfInterruptUint32();
     const void *addressOfInterruptParUint32();
--- a/js/src/jit/FixedList.h
+++ b/js/src/jit/FixedList.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_FixedList_h
 #define jit_FixedList_h
 
 #include <stddef.h>
 
 #include "jit/Ion.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 
 namespace js {
 namespace jit {
 
 // List of a fixed length, but the length is unknown until runtime.
 template <typename T>
 class FixedList
 {
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -54,98 +54,98 @@
 using namespace js;
 using namespace js::jit;
 
 using mozilla::ThreadLocal;
 
 // Assert that JitCode is gc::Cell aligned.
 JS_STATIC_ASSERT(sizeof(JitCode) % gc::CellSize == 0);
 
-static ThreadLocal<IonContext*> TlsIonContext;
-
-static IonContext *
-CurrentIonContext()
+static ThreadLocal<JitContext*> TlsJitContext;
+
+static JitContext *
+CurrentJitContext()
 {
-    if (!TlsIonContext.initialized())
+    if (!TlsJitContext.initialized())
         return nullptr;
-    return TlsIonContext.get();
+    return TlsJitContext.get();
 }
 
 void
-jit::SetIonContext(IonContext *ctx)
+jit::SetJitContext(JitContext *ctx)
 {
-    TlsIonContext.set(ctx);
+    TlsJitContext.set(ctx);
 }
 
-IonContext *
-jit::GetIonContext()
+JitContext *
+jit::GetJitContext()
 {
-    MOZ_ASSERT(CurrentIonContext());
-    return CurrentIonContext();
+    MOZ_ASSERT(CurrentJitContext());
+    return CurrentJitContext();
 }
 
-IonContext *
-jit::MaybeGetIonContext()
+JitContext *
+jit::MaybeGetJitContext()
 {
-    return CurrentIonContext();
+    return CurrentJitContext();
 }
 
-IonContext::IonContext(JSContext *cx, TempAllocator *temp)
+JitContext::JitContext(JSContext *cx, TempAllocator *temp)
   : cx(cx),
     temp(temp),
     runtime(CompileRuntime::get(cx->runtime())),
     compartment(CompileCompartment::get(cx->compartment())),
-    prev_(CurrentIonContext()),
+    prev_(CurrentJitContext()),
     assemblerCount_(0)
 {
-    SetIonContext(this);
+    SetJitContext(this);
 }
 
-IonContext::IonContext(ExclusiveContext *cx, TempAllocator *temp)
+JitContext::JitContext(ExclusiveContext *cx, TempAllocator *temp)
   : cx(nullptr),
     temp(temp),
     runtime(CompileRuntime::get(cx->runtime_)),
     compartment(nullptr),
-    prev_(CurrentIonContext()),
+    prev_(CurrentJitContext()),
     assemblerCount_(0)
 {
-    SetIonContext(this);
+    SetJitContext(this);
 }
 
-IonContext::IonContext(CompileRuntime *rt, CompileCompartment *comp, TempAllocator *temp)
+JitContext::JitContext(CompileRuntime *rt, CompileCompartment *comp, TempAllocator *temp)
   : cx(nullptr),
     temp(temp),
     runtime(rt),
     compartment(comp),
-    prev_(CurrentIonContext()),
+    prev_(CurrentJitContext()),
     assemblerCount_(0)
 {
-    SetIonContext(this);
+    SetJitContext(this);
 }
 
-IonContext::IonContext(CompileRuntime *rt)
+JitContext::JitContext(CompileRuntime *rt)
   : cx(nullptr),
     temp(nullptr),
     runtime(rt),
     compartment(nullptr),
-    prev_(CurrentIonContext()),
+    prev_(CurrentJitContext()),
     assemblerCount_(0)
 {
-    SetIonContext(this);
+    SetJitContext(this);
 }
 
-IonContext::~IonContext()
+JitContext::~JitContext()
 {
-    SetIonContext(prev_);
+    SetJitContext(prev_);
 }
 
 bool
 jit::InitializeIon()
 {
-    if (!TlsIonContext.initialized() && !TlsIonContext.init())
+    if (!TlsJitContext.initialized() && !TlsJitContext.init())
         return false;
     CheckLogging();
 #if defined(JS_CODEGEN_ARM)
     InitARMFlags();
 #endif
     CheckPerf();
     return true;
 }
@@ -188,17 +188,17 @@ JitRuntime::~JitRuntime()
 
 bool
 JitRuntime::initialize(JSContext *cx)
 {
     MOZ_ASSERT(cx->runtime()->currentThreadHasExclusiveAccess());
 
     AutoCompartment ac(cx, cx->atomsCompartment());
 
-    IonContext ictx(cx, nullptr);
+    JitContext jctx(cx, nullptr);
 
     execAlloc_ = cx->runtime()->getExecAlloc(cx);
     if (!execAlloc_)
         return false;
 
     if (!cx->compartment()->ensureJitCompartmentExists(cx))
         return false;
 
@@ -538,17 +538,17 @@ jit::LazyLinkTopActivation(JSContext *cx
     // Remove from pending.
     builder->remove();
 
     if (CodeGenerator *codegen = builder->backgroundCodegen()) {
         js::TraceLogger *logger = TraceLoggerForMainThread(cx->runtime());
         AutoTraceLog logScript(logger, TraceLogCreateTextId(logger, script));
         AutoTraceLog logLink(logger, TraceLogger::IonLinking);
 
-        IonContext ictx(cx, &builder->alloc());
+        JitContext jctx(cx, &builder->alloc());
 
         // Root the assembler until the builder is finished below. As it
         // was constructed off thread, the assembler has not been rooted
         // previously, though any GC activity would discard the builder.
         codegen->masm.constructRoot(cx);
 
         if (!codegen->link(cx, builder->constraints())) {
             // Silently ignore OOM during code generation. The assembly code
@@ -1261,18 +1261,18 @@ jit::ToggleBarriers(JS::Zone *zone, bool
 namespace js {
 namespace jit {
 
 bool
 OptimizeMIR(MIRGenerator *mir)
 {
     MIRGraph &graph = mir->graph();
     TraceLogger *logger;
-    if (GetIonContext()->runtime->onMainThread())
-        logger = TraceLoggerForMainThread(GetIonContext()->runtime);
+    if (GetJitContext()->runtime->onMainThread())
+        logger = TraceLoggerForMainThread(GetJitContext()->runtime);
     else
         logger = TraceLoggerForCurrentThread();
 
     if (!mir->compilingAsmJS()) {
         if (!MakeMRegExpHoistable(graph))
             return false;
     }
 
@@ -1593,18 +1593,18 @@ OptimizeMIR(MIRGenerator *mir)
 }
 
 LIRGraph *
 GenerateLIR(MIRGenerator *mir)
 {
     MIRGraph &graph = mir->graph();
 
     TraceLogger *logger;
-    if (GetIonContext()->runtime->onMainThread())
-        logger = TraceLoggerForMainThread(GetIonContext()->runtime);
+    if (GetJitContext()->runtime->onMainThread())
+        logger = TraceLoggerForMainThread(GetJitContext()->runtime);
     else
         logger = TraceLoggerForCurrentThread();
 
     LIRGraph *lir = mir->alloc().lifoAlloc()->new_<LIRGraph>(&graph);
     if (!lir || !lir->init())
         return nullptr;
 
     LIRGenerator lirgen(mir, graph, *lir);
@@ -1687,18 +1687,18 @@ GenerateLIR(MIRGenerator *mir)
 
     return lir;
 }
 
 CodeGenerator *
 GenerateCode(MIRGenerator *mir, LIRGraph *lir)
 {
     TraceLogger *logger;
-    if (GetIonContext()->runtime->onMainThread())
-        logger = TraceLoggerForMainThread(GetIonContext()->runtime);
+    if (GetJitContext()->runtime->onMainThread())
+        logger = TraceLoggerForMainThread(GetJitContext()->runtime);
     else
         logger = TraceLoggerForCurrentThread();
     AutoTraceLog log(logger, TraceLogger::GenerateCode);
 
     CodeGenerator *codegen = js_new<CodeGenerator>(mir, lir);
     if (!codegen)
         return nullptr;
 
@@ -1784,17 +1784,17 @@ AttachFinishedCompilations(JSContext *cx
                 builder->script()->setPendingIonBuilder(cx, builder);
                 HelperThreadState().ionLazyLinkList().insertFront(builder);
                 continue;
             }
         }
 
         if (CodeGenerator *codegen = builder->backgroundCodegen()) {
             RootedScript script(cx, builder->script());
-            IonContext ictx(cx, &builder->alloc());
+            JitContext jctx(cx, &builder->alloc());
             AutoTraceLog logScript(logger, TraceLogCreateTextId(logger, script));
             AutoTraceLog logLink(logger, TraceLogger::IonLinking);
 
             // Root the assembler until the builder is finished below. As it
             // was constructed off thread, the assembler has not been rooted
             // previously, though any GC activity would discard the builder.
             codegen->masm.constructRoot(cx);
 
@@ -1886,17 +1886,17 @@ IonCompile(JSContext *cx, JSScript *scri
         return AbortReason_Alloc;
 
     ScopedJSDeletePtr<LifoAlloc> autoDelete(alloc);
 
     TempAllocator *temp = alloc->new_<TempAllocator>(alloc);
     if (!temp)
         return AbortReason_Alloc;
 
-    IonContext ictx(cx, temp);
+    JitContext jctx(cx, temp);
 
     types::AutoEnterAnalysis enter(cx);
 
     if (!cx->compartment()->ensureJitCompartmentExists(cx))
         return AbortReason_Alloc;
 
     if (!cx->compartment()->jitCompartment()->ensureIonStubsExist(cx))
         return AbortReason_Alloc;
@@ -2417,20 +2417,20 @@ jit::CanEnterUsingFastInvoke(JSContext *
         return Method_Error;
 
     if (!script->hasIonScript())
         return Method_Skipped;
 
     return Method_Compiled;
 }
 
-static IonExecStatus
+static JitExecStatus
 EnterIon(JSContext *cx, EnterJitData &data)
 {
-    JS_CHECK_RECURSION(cx, return IonExec_Aborted);
+    JS_CHECK_RECURSION(cx, return JitExec_Aborted);
     MOZ_ASSERT(jit::IsIonEnabled(cx));
     MOZ_ASSERT(!data.osrFrame);
 
     EnterJitCode enter = cx->runtime()->jitRuntime()->enterIon();
 
     // Caller must construct |this| before invoking the Ion function.
     MOZ_ASSERT_IF(data.constructing, data.maxArgv[0].isObject());
 
@@ -2448,17 +2448,17 @@ EnterIon(JSContext *cx, EnterJitData &da
     // Jit callers wrap primitive constructor return.
     if (!data.result.isMagic() && data.constructing && data.result.isPrimitive())
         data.result = data.maxArgv[0];
 
     // Release temporary buffer used for OSR into Ion.
     cx->runtime()->getJitRuntime(cx)->freeOsrTempData();
 
     MOZ_ASSERT_IF(data.result.isMagic(), data.result.isMagic(JS_ION_ERROR));
-    return data.result.isMagic() ? IonExec_Error : IonExec_Ok;
+    return data.result.isMagic() ? JitExec_Error : JitExec_Ok;
 }
 
 bool
 jit::SetEnterJitData(JSContext *cx, EnterJitData &data, RunState &state, AutoValueVector &vals)
 {
     data.osrFrame = nullptr;
 
     if (state.isInvoke()) {
@@ -2503,40 +2503,40 @@ jit::SetEnterJitData(JSContext *cx, Ente
             if (iter.isFunctionFrame())
                 data.calleeToken = CalleeToToken(iter.callee(), /* constructing = */ false);
         }
     }
 
     return true;
 }
 
-IonExecStatus
+JitExecStatus
 jit::IonCannon(JSContext *cx, RunState &state)
 {
     IonScript *ion = state.script()->ionScript();
 
     EnterJitData data(cx);
     data.jitcode = ion->method()->raw();
 
     AutoValueVector vals(cx);
     if (!SetEnterJitData(cx, data, state, vals))
-        return IonExec_Error;
-
-    IonExecStatus status = EnterIon(cx, data);
-
-    if (status == IonExec_Ok)
+        return JitExec_Error;
+
+    JitExecStatus status = EnterIon(cx, data);
+
+    if (status == JitExec_Ok)
         state.setReturnValue(data.result);
 
     return status;
 }
 
-IonExecStatus
+JitExecStatus
 jit::FastInvoke(JSContext *cx, HandleFunction fun, CallArgs &args)
 {
-    JS_CHECK_RECURSION(cx, return IonExec_Error);
+    JS_CHECK_RECURSION(cx, return JitExec_Error);
 
     IonScript *ion = fun->nonLazyScript()->ionScript();
     JitCode *code = ion->method();
     void *jitcode = code->raw();
 
     MOZ_ASSERT(jit::IsIonEnabled(cx));
     MOZ_ASSERT(!ion->bailoutExpected());
 
@@ -2551,17 +2551,17 @@ jit::FastInvoke(JSContext *cx, HandleFun
     CALL_GENERATED_CODE(enter, jitcode, args.length() + 1, args.array() - 1, /* osrFrame = */nullptr,
                         calleeToken, /* scopeChain = */ nullptr, 0, result.address());
 
     MOZ_ASSERT(!cx->runtime()->jitRuntime()->hasIonReturnOverride());
 
     args.rval().set(result);
 
     MOZ_ASSERT_IF(result.isMagic(), result.isMagic(JS_ION_ERROR));
-    return result.isMagic() ? IonExec_Error : IonExec_Ok;
+    return result.isMagic() ? JitExec_Error : JitExec_Ok;
 }
 
 static void
 InvalidateActivation(FreeOp *fop, const JitActivationIterator &activations, bool invalidateAll)
 {
     JitSpew(JitSpew_IonInvalidate, "BEGIN invalidating activation");
 
     size_t frameno = 1;
@@ -3140,30 +3140,30 @@ jit::SizeOfIonData(JSScript *script, moz
 
     if (script->hasParallelIonScript())
         result += script->parallelIonScript()->sizeOfIncludingThis(mallocSizeOf);
 
     return result;
 }
 
 void
-jit::DestroyIonScripts(FreeOp *fop, JSScript *script)
+jit::DestroyJitScripts(FreeOp *fop, JSScript *script)
 {
     if (script->hasIonScript())
         jit::IonScript::Destroy(fop, script->ionScript());
 
     if (script->hasParallelIonScript())
         jit::IonScript::Destroy(fop, script->parallelIonScript());
 
     if (script->hasBaselineScript())
         jit::BaselineScript::Destroy(fop, script->baselineScript());
 }
 
 void
-jit::TraceIonScripts(JSTracer* trc, JSScript *script)
+jit::TraceJitScripts(JSTracer* trc, JSScript *script)
 {
     if (script->hasIonScript())
         jit::IonScript::Trace(trc, script->ionScript());
 
     if (script->hasParallelIonScript())
         jit::IonScript::Trace(trc, script->parallelIonScript());
 
     if (script->hasBaselineScript())
--- a/js/src/jit/Ion.h
+++ b/js/src/jit/Ion.h
@@ -32,29 +32,29 @@ enum AbortReason {
     AbortReason_Alloc,
     AbortReason_Inlining,
     AbortReason_NewScriptProperties,
     AbortReason_Disable,
     AbortReason_Error,
     AbortReason_NoAbort
 };
 
-// An Ion context is needed to enter into either an Ion method or an instance
-// of the Ion compiler. It points to a temporary allocator and the active
+// A JIT context is needed to enter into either an JIT method or an instance
+// of a JIT compiler. It points to a temporary allocator and the active
 // JSContext, either of which may be nullptr, and the active compartment, which
 // will not be nullptr.
 
-class IonContext
+class JitContext
 {
   public:
-    IonContext(JSContext *cx, TempAllocator *temp);
-    IonContext(ExclusiveContext *cx, TempAllocator *temp);
-    IonContext(CompileRuntime *rt, CompileCompartment *comp, TempAllocator *temp);
-    explicit IonContext(CompileRuntime *rt);
-    ~IonContext();
+    JitContext(JSContext *cx, TempAllocator *temp);
+    JitContext(ExclusiveContext *cx, TempAllocator *temp);
+    JitContext(CompileRuntime *rt, CompileCompartment *comp, TempAllocator *temp);
+    explicit JitContext(CompileRuntime *rt);
+    ~JitContext();
 
     // Running context when executing on the main thread. Not available during
     // compilation.
     JSContext *cx;
 
     // Allocator for temporary memory during compilation.
     TempAllocator *temp;
 
@@ -62,71 +62,71 @@ class IonContext
     // during compilation.
     CompileRuntime *runtime;
     CompileCompartment *compartment;
 
     int getNextAssemblerId() {
         return assemblerCount_++;
     }
   private:
-    IonContext *prev_;
+    JitContext *prev_;
     int assemblerCount_;
 };
 
 // Initialize Ion statically for all JSRuntimes.
 bool InitializeIon();
 
-// Get and set the current Ion context.
-IonContext *GetIonContext();
-IonContext *MaybeGetIonContext();
+// Get and set the current JIT context.
+JitContext *GetJitContext();
+JitContext *MaybeGetJitContext();
 
-void SetIonContext(IonContext *ctx);
+void SetJitContext(JitContext *ctx);
 
 bool CanIonCompileScript(JSContext *cx, JSScript *script, bool osr);
 
 MethodStatus CanEnterAtBranch(JSContext *cx, JSScript *script,
                               BaselineFrame *frame, jsbytecode *pc);
 MethodStatus CanEnter(JSContext *cx, RunState &state);
 MethodStatus CompileFunctionForBaseline(JSContext *cx, HandleScript script, BaselineFrame *frame);
 MethodStatus CanEnterUsingFastInvoke(JSContext *cx, HandleScript script, uint32_t numActualArgs);
 
 MethodStatus CanEnterInParallel(JSContext *cx, HandleScript script);
 
 MethodStatus
 Recompile(JSContext *cx, HandleScript script, BaselineFrame *osrFrame, jsbytecode *osrPc,
           bool constructing, bool force);
 
-enum IonExecStatus
+enum JitExecStatus
 {
     // The method call had to be aborted due to a stack limit check. This
     // error indicates that Ion never attempted to clean up frames.
-    IonExec_Aborted,
+    JitExec_Aborted,
 
     // The method call resulted in an error, and IonMonkey has cleaned up
     // frames.
-    IonExec_Error,
+    JitExec_Error,
 
-    // The method call succeeed and returned a value.
-    IonExec_Ok
+    // The method call succeeded and returned a value.
+    JitExec_Ok
 };
 
 static inline bool
-IsErrorStatus(IonExecStatus status)
+IsErrorStatus(JitExecStatus status)
 {
-    return status == IonExec_Error || status == IonExec_Aborted;
+    return status == JitExec_Error || status == JitExec_Aborted;
 }
 
 struct EnterJitData;
 
 bool SetEnterJitData(JSContext *cx, EnterJitData &data, RunState &state, AutoValueVector &vals);
 
-IonExecStatus IonCannon(JSContext *cx, RunState &state);
+JitExecStatus IonCannon(JSContext *cx, RunState &state);
 
 // Used to enter Ion from C++ natives like Array.map. Called from FastInvokeGuard.
-IonExecStatus FastInvoke(JSContext *cx, HandleFunction fun, CallArgs &args);
+JitExecStatus FastInvoke(JSContext *cx, HandleFunction fun, CallArgs &args);
 
 // Walk the stack and invalidate active Ion frames for the invalid scripts.
 void Invalidate(types::TypeZone &types, FreeOp *fop,
                 const types::RecompileInfoVector &invalid, bool resetUses = true,
                 bool cancelOffThread = true);
 void Invalidate(JSContext *cx, const types::RecompileInfoVector &invalid, bool resetUses = true,
                 bool cancelOffThread = true);
 bool Invalidate(JSContext *cx, JSScript *script, ExecutionMode mode, bool resetUses = true,
@@ -193,18 +193,18 @@ NumLocalsAndArgs(JSScript *script)
     return num;
 }
 
 void ForbidCompilation(JSContext *cx, JSScript *script);
 void ForbidCompilation(JSContext *cx, JSScript *script, ExecutionMode mode);
 
 void PurgeCaches(JSScript *script);
 size_t SizeOfIonData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf);
-void DestroyIonScripts(FreeOp *fop, JSScript *script);
-void TraceIonScripts(JSTracer* trc, JSScript *script);
+void DestroyJitScripts(FreeOp *fop, JSScript *script);
+void TraceJitScripts(JSTracer* trc, JSScript *script);
 
 bool JitSupportsFloatingPoint();
 bool JitSupportsSimd();
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_Ion_h */
--- a/js/src/jit/IonAnalysis.cpp
+++ b/js/src/jit/IonAnalysis.cpp
@@ -1645,17 +1645,17 @@ ComputeImmediateDominators(MIRGraph &gra
 #endif
 }
 
 bool
 jit::BuildDominatorTree(MIRGraph &graph)
 {
     ComputeImmediateDominators(graph);
 
-    Vector<MBasicBlock *, 4, IonAllocPolicy> worklist(graph.alloc());
+    Vector<MBasicBlock *, 4, JitAllocPolicy> worklist(graph.alloc());
 
     // Traversing through the graph in post-order means that every non-phi use
     // of a definition is visited before the def itself. Since a def
     // dominates its uses, by the time we reach a particular
     // block, we have processed all of its dominated children, so
     // block->numDominated() is accurate.
     for (PostorderIterator i(graph.poBegin()); i != graph.poEnd(); i++) {
         MBasicBlock *child = *i;
@@ -2151,17 +2151,17 @@ struct BoundsCheckInfo
 {
     MBoundsCheck *check;
     uint32_t validEnd;
 };
 
 typedef HashMap<uint32_t,
                 BoundsCheckInfo,
                 DefaultHasher<uint32_t>,
-                IonAllocPolicy> BoundsCheckMap;
+                JitAllocPolicy> BoundsCheckMap;
 
 // Compute a hash for bounds checks which ignores constant offsets in the index.
 static HashNumber
 BoundsCheckHashIgnoreOffset(MBoundsCheck *check)
 {
     SimpleLinearSum indexSum = ExtractLinearSum(check->index());
     uintptr_t index = indexSum.term ? uintptr_t(indexSum.term) : 0;
     uintptr_t length = uintptr_t(check->length());
@@ -2482,17 +2482,17 @@ bool
 jit::EliminateRedundantChecks(MIRGraph &graph)
 {
     BoundsCheckMap checks(graph.alloc());
 
     if (!checks.init())
         return false;
 
     // Stack for pre-order CFG traversal.
-    Vector<MBasicBlock *, 1, IonAllocPolicy> worklist(graph.alloc());
+    Vector<MBasicBlock *, 1, JitAllocPolicy> worklist(graph.alloc());
 
     // The index of the current block in the CFG traversal.
     size_t index = 0;
 
     // Add all self-dominating blocks to the worklist.
     // This includes all roots. Order does not matter.
     for (MBasicBlockIterator i(graph.begin()); i != graph.end(); i++) {
         MBasicBlock *block = *i;
@@ -2662,17 +2662,17 @@ LinearSum::print(Sprinter &sp) const
         sp.printf("+%d", constant_);
     else if (constant_ < 0)
         sp.printf("%d", constant_);
 }
 
 void
 LinearSum::dump(FILE *fp) const
 {
-    Sprinter sp(GetIonContext()->cx);
+    Sprinter sp(GetJitContext()->cx);
     sp.init();
     print(sp);
     fprintf(fp, "%s\n", sp.string());
 }
 
 void
 LinearSum::dump() const
 {
@@ -2971,17 +2971,17 @@ jit::AnalyzeNewScriptDefiniteProperties(
     static const uint32_t MAX_SCRIPT_SIZE = 2000;
     if (script->length() > MAX_SCRIPT_SIZE)
         return true;
 
     Vector<PropertyName *> accessedProperties(cx);
 
     LifoAlloc alloc(TempAllocator::PreferredLifoChunkSize);
     TempAllocator temp(&alloc);
-    IonContext ictx(cx, &temp);
+    JitContext jctx(cx, &temp);
 
     if (!cx->compartment()->ensureJitCompartmentExists(cx))
         return false;
 
     if (!script->hasBaselineScript()) {
         MethodStatus status = BaselineCompile(cx, script);
         if (status == Method_Error)
             return false;
@@ -3210,17 +3210,17 @@ jit::AnalyzeArgumentsUsage(JSContext *cx
     if (script->length() > MAX_SCRIPT_SIZE)
         return true;
 
     if (!script->ensureHasTypes(cx))
         return false;
 
     LifoAlloc alloc(TempAllocator::PreferredLifoChunkSize);
     TempAllocator temp(&alloc);
-    IonContext ictx(cx, &temp);
+    JitContext jctx(cx, &temp);
 
     if (!cx->compartment()->ensureJitCompartmentExists(cx))
         return false;
 
     MIRGraph graph(&temp);
     InlineScriptTree *inlineScriptTree = InlineScriptTree::New(&temp, nullptr, nullptr, script);
     if (!inlineScriptTree)
         return false;
--- a/js/src/jit/IonAnalysis.h
+++ b/js/src/jit/IonAnalysis.h
@@ -4,17 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_IonAnalysis_h
 #define jit_IonAnalysis_h
 
 // This file declares various analysis passes that operate on MIR.
 
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/MIR.h"
 
 namespace js {
 namespace jit {
 
 class MIRGenerator;
 class MIRGraph;
 
@@ -148,17 +148,17 @@ class LinearSum
     LinearTerm term(size_t i) const { return terms_[i]; }
     void replaceTerm(size_t i, MDefinition *def) { terms_[i].term = def; }
 
     void print(Sprinter &sp) const;
     void dump(FILE *) const;
     void dump() const;
 
   private:
-    Vector<LinearTerm, 2, IonAllocPolicy> terms_;
+    Vector<LinearTerm, 2, JitAllocPolicy> terms_;
     int32_t constant_;
 };
 
 // Convert all components of a linear sum (except, optionally, the constant)
 // and add any new instructions to the end of block.
 MDefinition *
 ConvertLinearSum(TempAllocator &alloc, MBasicBlock *block, const LinearSum &sum,
                  bool convertConstant = false);
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -39,18 +39,18 @@ using mozilla::DebugOnly;
 using mozilla::Maybe;
 
 class jit::BaselineFrameInspector
 {
   public:
     types::Type thisType;
     JSObject *singletonScopeChain;
 
-    Vector<types::Type, 4, IonAllocPolicy> argTypes;
-    Vector<types::Type, 4, IonAllocPolicy> varTypes;
+    Vector<types::Type, 4, JitAllocPolicy> argTypes;
+    Vector<types::Type, 4, JitAllocPolicy> varTypes;
 
     explicit BaselineFrameInspector(TempAllocator *temp)
       : thisType(types::Type::UndefinedType()),
         singletonScopeChain(nullptr),
         argTypes(*temp),
         varTypes(*temp)
     {}
 };
@@ -1315,18 +1315,18 @@ IonBuilder::traverseBytecode()
         // popped by this opcode either:
         //
         //   (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());
+        Vector<MDefinition *, 4, JitAllocPolicy> popped(alloc());
+        Vector<size_t, 4, JitAllocPolicy> poppedUses(alloc());
         unsigned nuses = GetUseCount(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()))
                 return false;
         }
 #endif
@@ -7050,17 +7050,17 @@ jit::TypeSetIncludes(types::TypeSet *typ
     }
 }
 
 // Whether a write of the given value may need a post-write barrier for GC purposes.
 bool
 jit::NeedsPostBarrier(CompileInfo &info, MDefinition *value)
 {
 #ifdef JSGC_GENERATIONAL
-    if (!GetIonContext()->runtime->gcNursery().exists())
+    if (!GetJitContext()->runtime->gcNursery().exists())
         return false;
 #endif
     return info.executionMode() != ParallelExecution && value->mightBeType(MIRType_Object);
 }
 
 bool
 IonBuilder::setStaticName(JSObject *staticObject, PropertyName *name)
 {
--- a/js/src/jit/IonBuilder.h
+++ b/js/src/jit/IonBuilder.h
@@ -965,22 +965,22 @@ class IonBuilder
         jsbytecode *pc;
         MBasicBlock *header;
 
         LoopHeader(jsbytecode *pc, MBasicBlock *header)
           : pc(pc), header(header)
         {}
     };
 
-    Vector<CFGState, 8, IonAllocPolicy> cfgStack_;
-    Vector<ControlFlowInfo, 4, IonAllocPolicy> loops_;
-    Vector<ControlFlowInfo, 0, IonAllocPolicy> switches_;
-    Vector<ControlFlowInfo, 2, IonAllocPolicy> labels_;
-    Vector<MInstruction *, 2, IonAllocPolicy> iterators_;
-    Vector<LoopHeader, 0, IonAllocPolicy> loopHeaders_;
+    Vector<CFGState, 8, JitAllocPolicy> cfgStack_;
+    Vector<ControlFlowInfo, 4, JitAllocPolicy> loops_;
+    Vector<ControlFlowInfo, 0, JitAllocPolicy> switches_;
+    Vector<ControlFlowInfo, 2, JitAllocPolicy> labels_;
+    Vector<MInstruction *, 2, JitAllocPolicy> iterators_;
+    Vector<LoopHeader, 0, JitAllocPolicy> loopHeaders_;
     BaselineInspector *inspector;
 
     size_t inliningDepth_;
 
     // Cutoff to disable compilation if excessive time is spent reanalyzing
     // loop bodies to compute a fixpoint of the types for loop variables.
     static const size_t MAX_LOOP_RESTARTS = 40;
     size_t numLoopRestarts_;
--- a/js/src/jit/IonCaches.cpp
+++ b/js/src/jit/IonCaches.cpp
@@ -9,28 +9,28 @@
 #include "mozilla/TemplateLib.h"
 
 #include "jsproxy.h"
 #include "jstypes.h"
 
 #include "builtin/TypedObject.h"
 #include "jit/BaselineIC.h"
 #include "jit/Ion.h"
-#include "jit/IonLinker.h"
 #include "jit/JitcodeMap.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #include "jit/Lowering.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/ParallelFunctions.h"
 #include "jit/VMFunctions.h"
 #include "vm/Shape.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 using mozilla::tl::FloorLog2;
 
@@ -1217,17 +1217,17 @@ bool
 GetPropertyIC::allowArrayLength(Context cx, HandleObject obj) const
 {
     if (!idempotent())
         return true;
 
     uint32_t locationIndex, numLocations;
     getLocationInfo(&locationIndex, &numLocations);
 
-    IonScript *ion = GetTopIonJSScript(cx)->ionScript();
+    IonScript *ion = GetTopJitJSScript(cx)->ionScript();
     CacheLocation *locs = ion->getCacheLocs(locationIndex);
     for (size_t i = 0; i < numLocations; i++) {
         CacheLocation &curLoc = locs[i];
         types::StackTypeSet *bcTypes =
             types::TypeScript::BytecodeTypes(curLoc.script, curLoc.pc);
 
         if (!bcTypes->hasType(types::Type::Int32Type()))
             return false;
@@ -1717,17 +1717,17 @@ GetPropertyIC::tryAttachStub(JSContext *
     return true;
 }
 
 /* static */ bool
 GetPropertyIC::update(JSContext *cx, size_t cacheIndex,
                       HandleObject obj, MutableHandleValue vp)
 {
     void *returnAddr;
-    RootedScript outerScript(cx, GetTopIonJSScript(cx, &returnAddr));
+    RootedScript outerScript(cx, GetTopJitJSScript(cx, &returnAddr));
     IonScript *ion = outerScript->ionScript();
 
     GetPropertyIC &cache = ion->getCache(cacheIndex).toGetProperty();
     RootedPropertyName name(cx, cache.name());
 
     // Override the return value if we are invalidated (bug 728188).
     AutoDetectInvalidation adi(cx, vp, ion);
 
@@ -1880,17 +1880,17 @@ GetPropertyParIC::attachTypedArrayLength
     setHasTypedArrayLengthStub(obj);
     return linkAndAttachStub(cx, masm, attacher, ion, "parallel typed array length");
 }
 
 bool
 GetPropertyParIC::update(ForkJoinContext *cx, size_t cacheIndex,
                          HandleObject obj, MutableHandleValue vp)
 {
-    IonScript *ion = GetTopIonJSScript(cx)->parallelIonScript();
+    IonScript *ion = GetTopJitJSScript(cx)->parallelIonScript();
     GetPropertyParIC &cache = ion->getCache(cacheIndex).toGetPropertyPar();
 
     // Grab the property early, as the pure path is fast anyways and doesn't
     // need a lock. If we can't do it purely, bail out of parallel execution.
     if (!GetPropertyPure(cx, obj, NameToId(cache.name()), vp.address()))
         return false;
 
     // Avoid unnecessary locking if cannot attach stubs.
@@ -2815,17 +2815,17 @@ CanAttachNativeSetProp(ThreadSafeContext
     return SetPropertyIC::CanAttachNone;
 }
 
 bool
 SetPropertyIC::update(JSContext *cx, size_t cacheIndex, HandleObject obj,
                       HandleValue value)
 {
     void *returnAddr;
-    RootedScript script(cx, GetTopIonJSScript(cx, &returnAddr));
+    RootedScript script(cx, GetTopJitJSScript(cx, &returnAddr));
     IonScript *ion = script->ionScript();
     SetPropertyIC &cache = ion->getCache(cacheIndex).toSetProperty();
     RootedPropertyName name(cx, cache.name());
     RootedId id(cx, AtomToId(name));
 
     RootedTypeObject oldType(cx, obj->getType(cx));
     if (!oldType)
         return false;
@@ -2911,17 +2911,17 @@ SetPropertyIC::reset()
 }
 
 bool
 SetPropertyParIC::update(ForkJoinContext *cx, size_t cacheIndex, HandleObject obj,
                          HandleValue value)
 {
     MOZ_ASSERT(cx->isThreadLocal(obj));
 
-    IonScript *ion = GetTopIonJSScript(cx)->parallelIonScript();
+    IonScript *ion = GetTopJitJSScript(cx)->parallelIonScript();
     SetPropertyParIC &cache = ion->getCache(cacheIndex).toSetPropertyPar();
 
     RootedValue v(cx, value);
     RootedId id(cx, AtomToId(cache.name()));
 
     if (!obj->isNative())
         return false;
     RootedNativeObject nobj(cx, &obj->as<NativeObject>());
@@ -3475,17 +3475,17 @@ GetElementIC::attachArgumentsElement(JSC
     return linkAndAttachStub(cx, masm, attacher, ion, "ArgsObj element (normal)");
 }
 
 bool
 GetElementIC::update(JSContext *cx, size_t cacheIndex, HandleObject obj,
                      HandleValue idval, MutableHandleValue res)
 {
     void *returnAddr;
-    RootedScript outerScript(cx, GetTopIonJSScript(cx, &returnAddr));
+    RootedScript outerScript(cx, GetTopJitJSScript(cx, &returnAddr));
     IonScript *ion = outerScript->ionScript();
     GetElementIC &cache = ion->getCache(cacheIndex).toGetElement();
     RootedScript script(cx);
     jsbytecode *pc;
     cache.getScriptedLocation(&script, &pc);
 
     // Override the return value when the script is invalidated (bug 728188).
     AutoDetectInvalidation adi(cx, res, ion);
@@ -3865,17 +3865,17 @@ SetElementIC::attachTypedArrayElement(JS
 
     return linkAndAttachStub(cx, masm, attacher, ion, "typed array");
 }
 
 bool
 SetElementIC::update(JSContext *cx, size_t cacheIndex, HandleObject obj,
                      HandleValue idval, HandleValue value)
 {
-    RootedScript outerScript(cx, GetTopIonJSScript(cx));
+    RootedScript outerScript(cx, GetTopJitJSScript(cx));
     IonScript *ion = outerScript->ionScript();
     SetElementIC &cache = ion->getCache(cacheIndex).toSetElement();
 
     bool attachedStub = false;
     if (cache.canAttachStub()) {
         if (!cache.hasDenseStub() && IsDenseElementSetInlineable(obj, idval)) {
             if (!cache.attachDenseElement(cx, outerScript, ion, obj, idval))
                 return false;
@@ -3935,17 +3935,17 @@ SetElementParIC::attachTypedArrayElement
 
     return linkAndAttachStub(cx, masm, attacher, ion, "parallel typed array");
 }
 
 bool
 SetElementParIC::update(ForkJoinContext *cx, size_t cacheIndex, HandleObject obj,
                         HandleValue idval, HandleValue value)
 {
-    IonScript *ion = GetTopIonJSScript(cx)->parallelIonScript();
+    IonScript *ion = GetTopJitJSScript(cx)->parallelIonScript();
     SetElementParIC &cache = ion->getCache(cacheIndex).toSetElementPar();
 
     // Avoid unnecessary locking if cannot attach stubs.
     if (!cache.canAttachStub())
         return SetElementPar(cx, obj, idval, value, cache.strict());
 
     {
         LockedJSContext ncx(cx);
@@ -4014,17 +4014,17 @@ GetElementParIC::attachTypedArrayElement
                                  allowDoubleResult());
     return linkAndAttachStub(cx, masm, attacher, ion, "parallel typed array");
 }
 
 bool
 GetElementParIC::update(ForkJoinContext *cx, size_t cacheIndex, HandleObject obj,
                         HandleValue idval, MutableHandleValue vp)
 {
-    IonScript *ion = GetTopIonJSScript(cx)->parallelIonScript();
+    IonScript *ion = GetTopJitJSScript(cx)->parallelIonScript();
     GetElementParIC &cache = ion->getCache(cacheIndex).toGetElementPar();
 
     // Try to get the element early, as the pure path doesn't need a lock. If
     // we can't do it purely, bail out of parallel execution.
     if (!GetObjectElementOperationPure(cx, obj, idval, vp.address()))
         return false;
 
     // Avoid unnecessary locking if cannot attach stubs.
@@ -4218,17 +4218,17 @@ IsCacheableNonGlobalScopeChain(JSObject 
     }
 
     MOZ_CRASH("Invalid scope chain");
 }
 
 JSObject *
 BindNameIC::update(JSContext *cx, size_t cacheIndex, HandleObject scopeChain)
 {
-    RootedScript outerScript(cx, GetTopIonJSScript(cx));
+    RootedScript outerScript(cx, GetTopJitJSScript(cx));
     IonScript *ion = outerScript->ionScript();
     BindNameIC &cache = ion->getCache(cacheIndex).toBindName();
     HandlePropertyName name = cache.name();
 
     RootedObject holder(cx);
     if (scopeChain->is<GlobalObject>()) {
         holder = scopeChain;
     } else {
@@ -4369,17 +4369,17 @@ IsCacheableNameCallGetter(HandleObject s
         IsCacheableGetPropCallPropertyOp(obj, holder, shape);
 }
 
 bool
 NameIC::update(JSContext *cx, size_t cacheIndex, HandleObject scopeChain,
                MutableHandleValue vp)
 {
     void *returnAddr;
-    RootedScript outerScript(cx, GetTopIonJSScript(cx, &returnAddr));
+    RootedScript outerScript(cx, GetTopJitJSScript(cx, &returnAddr));
     IonScript *ion = outerScript->ionScript();
 
     NameIC &cache = ion->getCache(cacheIndex).toName();
     RootedPropertyName name(cx, cache.name());
 
     RootedScript script(cx);
     jsbytecode *pc;
     cache.getScriptedLocation(&script, &pc);
@@ -4439,17 +4439,17 @@ JSObject *
 CallsiteCloneIC::update(JSContext *cx, size_t cacheIndex, HandleObject callee)
 {
     // Act as the identity for functions that are not clone-at-callsite, as we
     // generate this cache as long as some callees are clone-at-callsite.
     RootedFunction fun(cx, &callee->as<JSFunction>());
     if (!fun->hasScript() || !fun->nonLazyScript()->shouldCloneAtCallsite())
         return fun;
 
-    RootedScript outerScript(cx, GetTopIonJSScript(cx));
+    RootedScript outerScript(cx, GetTopJitJSScript(cx));
     IonScript *ion = outerScript->ionScript();
     CallsiteCloneIC &cache = ion->getCache(cacheIndex).toCallsiteClone();
 
     RootedFunction clone(cx, CloneFunctionAtCallsite(cx, fun, cache.callScript(), cache.callPc()));
     if (!clone)
         return nullptr;
 
     if (cache.canAttachStub()) {
--- a/js/src/jit/IonCode.h
+++ b/js/src/jit/IonCode.h
@@ -226,17 +226,17 @@ struct IonScript
     // Offset to and length of the safepoint table in bytes.
     uint32_t safepointsStart_;
     uint32_t safepointsSize_;
 
     // Number of bytes this function reserves on the stack.
     uint32_t frameSlots_;
 
     // Frame size is the value that can be added to the StackPointer along
-    // with the frame prefix to get a valid IonJSFrameLayout.
+    // with the frame prefix to get a valid JitFrameLayout.
     uint32_t frameSize_;
 
     // Table mapping bailout IDs to snapshot offsets.
     uint32_t bailoutTable_;
     uint32_t bailoutEntries_;
 
     // Map OSI-point displacement to snapshot.
     uint32_t osiIndexOffset_;
--- a/js/src/jit/JSONSpewer.cpp
+++ b/js/src/jit/JSONSpewer.cpp
@@ -264,17 +264,17 @@ JSONSpewer::spewMDef(MDefinition *def)
         integerValue(use.def()->id());
     endList();
 
     bool isTruncated = false;
     if (def->isAdd() || def->isSub() || def->isMod() || def->isMul() || def->isDiv())
         isTruncated = static_cast<MBinaryArithInstruction*>(def)->isTruncated();
 
     if (def->type() != MIRType_None && def->range()) {
-        Sprinter sp(GetIonContext()->cx);
+        Sprinter sp(GetJitContext()->cx);
         sp.init();
         def->range()->print(sp);
         stringProperty("type", "%s : %s%s", sp.string(), StringFromMIRType(def->type()), (isTruncated ? " (t)" : ""));
     } else {
         stringProperty("type", "%s%s", StringFromMIRType(def->type()), (isTruncated ? " (t)" : ""));
     }
 
     if (def->isInstruction()) {
rename from js/src/jit/IonAllocPolicy.h
rename to js/src/jit/JitAllocPolicy.h
--- a/js/src/jit/IonAllocPolicy.h
+++ b/js/src/jit/JitAllocPolicy.h
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef jit_IonAllocPolicy_h
-#define jit_IonAllocPolicy_h
+#ifndef jit_JitAllocPolicy_h
+#define jit_JitAllocPolicy_h
 
 #include "mozilla/GuardObjects.h"
 #include "mozilla/TypeTraits.h"
 
 #include "jscntxt.h"
 
 #include "ds/LifoAlloc.h"
 #include "jit/InlineList.h"
@@ -19,17 +19,17 @@
 namespace js {
 namespace jit {
 
 class TempAllocator
 {
     LifoAllocScope lifoScope_;
 
   public:
-    // Most infallible Ion allocations are small, so we use a ballast of 16
+    // Most infallible JIT allocations are small, so we use a ballast of 16
     // KiB. And with a ballast of 16 KiB, a chunk size of 32 KiB works well,
     // because TempAllocators with a peak allocation size of less than 16 KiB
     // (which is most of them) only have to allocate a single chunk.
     static const size_t BallastSize;            // 16 KiB
     static const size_t PreferredLifoChunkSize; // 32 KiB
 
     explicit TempAllocator(LifoAlloc *lifoAlloc)
       : lifoScope_(lifoAlloc)
@@ -64,22 +64,22 @@ class TempAllocator
         return &lifoScope_.alloc();
     }
 
     bool ensureBallast() {
         return lifoScope_.alloc().ensureUnusedApproximate(BallastSize);
     }
 };
 
-class IonAllocPolicy
+class JitAllocPolicy
 {
     TempAllocator &alloc_;
 
   public:
-    MOZ_IMPLICIT IonAllocPolicy(TempAllocator &alloc)
+    MOZ_IMPLICIT JitAllocPolicy(TempAllocator &alloc)
       : alloc_(alloc)
     {}
     template <typename T>
     T *pod_malloc(size_t numElems) {
         if (numElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value)
             return nullptr;
         return static_cast<T *>(alloc_.allocate(numElems * sizeof(T)));
     }
@@ -100,51 +100,51 @@ class IonAllocPolicy
         return n;
     }
     void free_(void *p) {
     }
     void reportAllocOverflow() const {
     }
 };
 
-class OldIonAllocPolicy
+class OldJitAllocPolicy
 {
   public:
-    OldIonAllocPolicy()
+    OldJitAllocPolicy()
     {}
     template <typename T>
     T *pod_malloc(size_t numElems) {
         if (numElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value)
             return nullptr;
-        return static_cast<T *>(GetIonContext()->temp->allocate(numElems * sizeof(T)));
+        return static_cast<T *>(GetJitContext()->temp->allocate(numElems * sizeof(T)));
     }
     void free_(void *p) {
     }
     void reportAllocOverflow() const {
     }
 };
 
-class AutoIonContextAlloc
+class AutoJitContextAlloc
 {
     TempAllocator tempAlloc_;
-    IonContext *icx_;
+    JitContext *jcx_;
     TempAllocator *prevAlloc_;
 
   public:
-    explicit AutoIonContextAlloc(JSContext *cx)
+    explicit AutoJitContextAlloc(JSContext *cx)
       : tempAlloc_(&cx->tempLifoAlloc()),
-        icx_(GetIonContext()),
-        prevAlloc_(icx_->temp)
+        jcx_(GetJitContext()),
+        prevAlloc_(jcx_->temp)
     {
-        icx_->temp = &tempAlloc_;
+        jcx_->temp = &tempAlloc_;
     }
 
-    ~AutoIonContextAlloc() {
-        MOZ_ASSERT(icx_->temp == &tempAlloc_);
-        icx_->temp = prevAlloc_;
+    ~AutoJitContextAlloc() {
+        MOZ_ASSERT(jcx_->temp == &tempAlloc_);
+        jcx_->temp = prevAlloc_;
     }
 };
 
 struct TempObject
 {
     inline void *operator new(size_t nbytes, TempAllocator &alloc) {
         return alloc.allocateInfallible(nbytes);
     }
@@ -182,9 +182,9 @@ class TempObjectPool
     void clear() {
         freed_.clear();
     }
 };
 
 } // namespace jit
 } // namespace js
 
-#endif /* jit_IonAllocPolicy_h */
+#endif /* jit_JitAllocPolicy_h */
--- a/js/src/jit/JitCompartment.h
+++ b/js/src/jit/JitCompartment.h
@@ -8,17 +8,17 @@
 #define jit_JitCompartment_h
 
 #include "mozilla/MemoryReporting.h"
 
 #include "jsweakcache.h"
 
 #include "jit/CompileInfo.h"
 #include "jit/IonCode.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/shared/Assembler-shared.h"
 #include "js/Value.h"
 #include "vm/Stack.h"
 
 namespace js {
 namespace jit {
 
 class FrameSizeClass;
--- a/js/src/jit/JitFrameIterator-inl.h
+++ b/js/src/jit/JitFrameIterator-inl.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_JitFrameIterator_inl_h
 #define jit_JitFrameIterator_inl_h
 
 #include "jit/JitFrameIterator.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 
 namespace js {
 namespace jit {
 
 inline BaselineFrame *
 JitFrameIterator::baselineFrame() const
 {
     MOZ_ASSERT(isBaselineJS());
--- a/js/src/jit/JitFrameIterator.h
+++ b/js/src/jit/JitFrameIterator.h
@@ -73,19 +73,19 @@ enum ReadFrameArgsBehavior {
 
     // Only read overflown args (i.e. [callee()->nargs ... numActuals()]
     ReadFrame_Overflown,
 
     // Read all args (i.e. [0 ... numActuals()])
     ReadFrame_Actuals
 };
 
-class IonCommonFrameLayout;
-class IonJSFrameLayout;
-class IonExitFrameLayout;
+class CommonFrameLayout;
+class JitFrameLayout;
+class ExitFrameLayout;
 
 class BaselineFrame;
 
 class JitActivation;
 
 class JitFrameIterator
 {
   protected:
@@ -112,30 +112,30 @@ class JitFrameIterator
     }
     uint8_t *fp() const {
         return current_;
     }
     const JitActivation *activation() const {
         return activation_;
     }
 
-    IonCommonFrameLayout *current() const {
-        return (IonCommonFrameLayout *)current_;
+    CommonFrameLayout *current() const {
+        return (CommonFrameLayout *)current_;
     }
 
     inline uint8_t *returnAddress() const;
 
     // Return the pointer of the JitFrame, the iterator is assumed to be settled
     // on a scripted frame.
-    IonJSFrameLayout *jsFrame() const;
+    JitFrameLayout *jsFrame() const;
 
     // Returns true iff this exit frame was created using EnsureExitFrame.
     inline bool isFakeExitFrame() const;
 
-    inline IonExitFrameLayout *exitFrame() const;
+    inline ExitFrameLayout *exitFrame() const;
 
     // Returns whether the JS frame has been invalidated and, if so,
     // places the invalidated Ion script in |ionScript|.
     bool checkInvalidation(IonScript **ionScript) const;
     bool checkInvalidation() const;
 
     bool isScripted() const {
         return type_ == JitFrame_BaselineJS || type_ == JitFrame_IonJS || type_ == JitFrame_Bailout;
@@ -259,35 +259,35 @@ class JitFrameIterator
 class RInstructionResults
 {
     // Vector of results of recover instructions.
     typedef mozilla::Vector<RelocatableValue, 1, SystemAllocPolicy> Values;
     mozilla::UniquePtr<Values, JS::DeletePolicy<Values> > results_;
 
     // The frame pointer is used as a key to check if the current frame already
     // bailed out.
-    IonJSFrameLayout *fp_;
+    JitFrameLayout *fp_;
 
     // Record if we tried and succeed at allocating and filling the vector of
     // recover instruction results, if needed.  This flag is needed in order to
     // avoid evaluating the recover instruction twice.
     bool initialized_;
 
   public:
-    explicit RInstructionResults(IonJSFrameLayout *fp);
+    explicit RInstructionResults(JitFrameLayout *fp);
     RInstructionResults(RInstructionResults&& src);
 
     RInstructionResults& operator=(RInstructionResults&& rhs);
 
     ~RInstructionResults();
 
     bool init(JSContext *cx, uint32_t numResults);
     bool isInitialized() const;
 
-    IonJSFrameLayout *frame() const;
+    JitFrameLayout *frame() const;
 
     RelocatableValue& operator[](size_t index);
 
     void trace(JSTracer *trc);
 };
 
 struct MaybeReadFallback
 {
@@ -346,17 +346,17 @@ class RResumePoint;
 
 // Reads frame information in snapshot-encoding order (that is, outermost frame
 // to innermost frame).
 class SnapshotIterator
 {
   protected:
     SnapshotReader snapshot_;
     RecoverReader recover_;
-    IonJSFrameLayout *fp_;
+    JitFrameLayout *fp_;
     MachineState machine_;
     IonScript *ionScript_;
     RInstructionResults *instructionResults_;
 
   private:
     // Read a spilled register from the machine state.
     bool hasRegister(Register reg) const {
         return machine_.has(reg);
@@ -469,17 +469,17 @@ class SnapshotIterator
         return moreInstructions();
     }
 
   public:
     // Connect all informations about the current script in order to recover the
     // content of baseline frames.
 
     SnapshotIterator(IonScript *ionScript, SnapshotOffset snapshotOffset,
-                     IonJSFrameLayout *fp, const MachineState &machine);
+                     JitFrameLayout *fp, const MachineState &machine);
     explicit SnapshotIterator(const JitFrameIterator &iter);
     SnapshotIterator();
 
     Value read() {
         return allocationValue(readAllocation());
     }
 
     Value maybeRead(MaybeReadFallback &fallback) {
rename from js/src/jit/IonFrames-inl.h
rename to js/src/jit/JitFrames-inl.h
--- a/js/src/jit/IonFrames-inl.h
+++ b/js/src/jit/JitFrames-inl.h
@@ -1,18 +1,18 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef jit_IonFrames_inl_h
-#define jit_IonFrames_inl_h
+#ifndef jit_JitFrames_inl_h
+#define jit_JitFrames_inl_h
 
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 
 #include "jit/JitFrameIterator.h"
 #include "jit/LIR.h"
 #include "vm/ForkJoin.h"
 
 #include "jit/JitFrameIterator-inl.h"
 
 namespace js {
@@ -26,52 +26,52 @@ SafepointIndex::resolve()
 #ifdef DEBUG
     resolved = true;
 #endif
 }
 
 inline uint8_t *
 JitFrameIterator::returnAddress() const
 {
-    IonCommonFrameLayout *current = (IonCommonFrameLayout *) current_;
+    CommonFrameLayout *current = (CommonFrameLayout *) current_;
     return current->returnAddress();
 }
 
 inline size_t
 JitFrameIterator::prevFrameLocalSize() const
 {
-    IonCommonFrameLayout *current = (IonCommonFrameLayout *) current_;
+    CommonFrameLayout *current = (CommonFrameLayout *) current_;
     return current->prevFrameLocalSize();
 }
 
 inline FrameType
 JitFrameIterator::prevType() const
 {
-    IonCommonFrameLayout *current = (IonCommonFrameLayout *) current_;
+    CommonFrameLayout *current = (CommonFrameLayout *) current_;
     return current->prevType();
 }
 
 inline bool
 JitFrameIterator::isFakeExitFrame() const
 {
     bool res = (prevType() == JitFrame_Unwound_Rectifier ||
                 prevType() == JitFrame_Unwound_IonJS ||
                 prevType() == JitFrame_Unwound_BaselineJS ||
                 prevType() == JitFrame_Unwound_BaselineStub ||
                 (prevType() == JitFrame_Entry && type() == JitFrame_Exit));
     MOZ_ASSERT_IF(res, type() == JitFrame_Exit || type() == JitFrame_BaselineJS);
     return res;
 }
 
-inline IonExitFrameLayout *
+inline ExitFrameLayout *
 JitFrameIterator::exitFrame() const
 {
     MOZ_ASSERT(type() == JitFrame_Exit);
     MOZ_ASSERT(!isFakeExitFrame());
-    return (IonExitFrameLayout *) fp();
+    return (ExitFrameLayout *) fp();
 }
 
 inline BaselineFrame *
 GetTopBaselineFrame(JSContext *cx)
 {
     JitFrameIterator iter(cx);
     MOZ_ASSERT(iter.type() == JitFrame_Exit);
     ++iter;
@@ -79,9 +79,9 @@ GetTopBaselineFrame(JSContext *cx)
         ++iter;
     MOZ_ASSERT(iter.isBaselineJS());
     return iter.baselineFrame();
 }
 
 } // namespace jit
 } // namespace js
 
-#endif /* jit_IonFrames_inl_h */
+#endif /* jit_JitFrames_inl_h */
rename from js/src/jit/IonFrames.cpp
rename to js/src/jit/JitFrames.cpp
--- a/js/src/jit/IonFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -1,31 +1,31 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 
 #include "jsfun.h"
 #include "jsobj.h"
 #include "jsscript.h"
 
 #include "gc/ForkJoinNursery.h"
 #include "gc/Marking.h"
 #include "jit/BaselineDebugModeOSR.h"
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/Ion.h"
-#include "jit/IonMacroAssembler.h"
 #include "jit/JitcodeMap.h"
 #include "jit/JitCompartment.h"
 #include "jit/JitSpewer.h"
+#include "jit/MacroAssembler.h"
 #include "jit/ParallelFunctions.h"
 #include "jit/PcScriptCache.h"
 #include "jit/Recover.h"
 #include "jit/Safepoints.h"
 #include "jit/Snapshots.h"
 #include "jit/VMFunctions.h"
 #include "vm/ArgumentsObject.h"
 #include "vm/Debugger.h"
@@ -38,56 +38,56 @@
 #include "jit/JitFrameIterator-inl.h"
 #include "vm/Debugger-inl.h"
 #include "vm/Probes-inl.h"
 
 namespace js {
 namespace jit {
 
 // Given a slot index, returns the offset, in bytes, of that slot from an
-// IonJSFrameLayout. Slot distances are uniform across architectures, however,
+// JitFrameLayout. Slot distances are uniform across architectures, however,
 // the distance does depend on the size of the frame header.
 static inline int32_t
 OffsetOfFrameSlot(int32_t slot)
 {
     return -slot;
 }
 
 static inline uintptr_t
-ReadFrameSlot(IonJSFrameLayout *fp, int32_t slot)
+ReadFrameSlot(JitFrameLayout *fp, int32_t slot)
 {
     return *(uintptr_t *)((char *)fp + OffsetOfFrameSlot(slot));
 }
 
 static inline void
-WriteFrameSlot(IonJSFrameLayout *fp, int32_t slot, uintptr_t value)
+WriteFrameSlot(JitFrameLayout *fp, int32_t slot, uintptr_t value)
 {
     *(uintptr_t *)((char *)fp + OffsetOfFrameSlot(slot)) = value;
 }
 
 static inline double
-ReadFrameDoubleSlot(IonJSFrameLayout *fp, int32_t slot)
+ReadFrameDoubleSlot(JitFrameLayout *fp, int32_t slot)
 {
     return *(double *)((char *)fp + OffsetOfFrameSlot(slot));
 }
 
 static inline float
-ReadFrameFloat32Slot(IonJSFrameLayout *fp, int32_t slot)
+ReadFrameFloat32Slot(JitFrameLayout *fp, int32_t slot)
 {
     return *(float *)((char *)fp + OffsetOfFrameSlot(slot));
 }
 
 static inline int32_t
-ReadFrameInt32Slot(IonJSFrameLayout *fp, int32_t slot)
+ReadFrameInt32Slot(JitFrameLayout *fp, int32_t slot)
 {
     return *(int32_t *)((char *)fp + OffsetOfFrameSlot(slot));
 }
 
 static inline bool
-ReadFrameBooleanSlot(IonJSFrameLayout *fp, int32_t slot)
+ReadFrameBooleanSlot(JitFrameLayout *fp, int32_t slot)
 {
     return *(bool *)((char *)fp + OffsetOfFrameSlot(slot));
 }
 
 JitFrameIterator::JitFrameIterator()
   : current_(nullptr),
     type_(JitFrame_Exit),
     returnAddressToFp_(nullptr),
@@ -167,17 +167,17 @@ JitFrameIterator::checkInvalidation(IonS
     MOZ_ASSERT(ionScript->containsReturnAddress(returnAddr));
     *ionScriptOut = ionScript;
     return true;
 }
 
 CalleeToken
 JitFrameIterator::calleeToken() const
 {
-    return ((IonJSFrameLayout *) current_)->calleeToken();
+    return ((JitFrameLayout *) current_)->calleeToken();
 }
 
 JSFunction *
 JitFrameIterator::callee() const
 {
     MOZ_ASSERT(isScripted());
     MOZ_ASSERT(isFunctionFrame());
     return CalleeTokenToFunction(calleeToken());
@@ -269,31 +269,31 @@ JitFrameIterator::actualArgs() const
     return jsFrame()->argv() + 1;
 }
 
 static inline size_t
 SizeOfFramePrefix(FrameType type)
 {
     switch (type) {
       case JitFrame_Entry:
-        return IonEntryFrameLayout::Size();
+        return EntryFrameLayout::Size();
       case JitFrame_BaselineJS:
       case JitFrame_IonJS:
       case JitFrame_Bailout:
       case JitFrame_Unwound_BaselineJS:
       case JitFrame_Unwound_IonJS:
-        return IonJSFrameLayout::Size();
+        return JitFrameLayout::Size();
       case JitFrame_BaselineStub:
-        return IonBaselineStubFrameLayout::Size();
+        return BaselineStubFrameLayout::Size();
       case JitFrame_Rectifier:
-        return IonRectifierFrameLayout::Size();
+        return RectifierFrameLayout::Size();
       case JitFrame_Unwound_Rectifier:
         return IonUnwoundRectifierFrameLayout::Size();
       case JitFrame_Exit:
-        return IonExitFrameLayout::Size();
+        return ExitFrameLayout::Size();
       default:
         MOZ_CRASH("unknown frame type");
     }
 }
 
 uint8_t *
 JitFrameIterator::prevFp() const
 {
@@ -815,17 +815,17 @@ HandleException(ResumeFromException *rfe
                     rfe->kind = ResumeFromException::RESUME_FORCED_RETURN;
                     rfe->framePointer = iter.fp() - BaselineFrame::FramePointerOffset;
                     rfe->stackPointer = reinterpret_cast<uint8_t *>(frame);
                     return;
                 }
             }
         }
 
-        IonJSFrameLayout *current = iter.isScripted() ? iter.jsFrame() : nullptr;
+        JitFrameLayout *current = iter.isScripted() ? iter.jsFrame() : nullptr;
 
         ++iter;
 
         if (current) {
             // Unwind the frame by updating jitTop. This is necessary so that
             // (1) debugger exception unwind and leave frame hooks don't see this
             // frame when they use ScriptFrameIter, and (2) ScriptFrameIter does
             // not crash when accessing an IonScript that's destroyed by the
@@ -861,17 +861,17 @@ HandleParallelFailure(ResumeFromExceptio
 
     rfe->kind = ResumeFromException::RESUME_ENTRY_FRAME;
 
     MOZ_ASSERT(frameIter.done());
     rfe->stackPointer = frameIter.fp();
 }
 
 void
-EnsureExitFrame(IonCommonFrameLayout *frame)
+EnsureExitFrame(CommonFrameLayout *frame)
 {
     if (frame->prevType() == JitFrame_Unwound_IonJS ||
         frame->prevType() == JitFrame_Unwound_BaselineJS ||
         frame->prevType() == JitFrame_Unwound_BaselineStub ||
         frame->prevType() == JitFrame_Unwound_Rectifier)
     {
         // Already an exit frame, nothing to do.
         return;
@@ -949,17 +949,17 @@ ReadAllocation(const JitFrameIterator &f
 
 static void
 MarkFrameAndActualArguments(JSTracer *trc, const JitFrameIterator &frame)
 {
     // The trampoline produced by |generateEnterJit| is pushing |this| on the
     // stack, as requested by |setEnterJitData|.  Thus, this function is also
     // used for marking the |this| value of the top-level frame.
 
-    IonJSFrameLayout *layout = frame.jsFrame();
+    JitFrameLayout *layout = frame.jsFrame();
 
     size_t nargs = frame.numActualArgs();
     MOZ_ASSERT_IF(!CalleeTokenIsFunction(layout->calleeToken()), nargs == 0);
 
     // Trace function arguments. Note + 1 for thisv.
     Value *argv = layout->argv();
     for (size_t i = 0; i < nargs + 1; i++)
         gc::MarkValueRoot(trc, &argv[i], "ion-argv");
@@ -983,17 +983,17 @@ WriteAllocation(const JitFrameIterator &
     uint8_t *argv = reinterpret_cast<uint8_t *>(frame.jsFrame()->argv());
     *reinterpret_cast<uintptr_t *>(argv + index) = value;
 }
 #endif
 
 static void
 MarkIonJSFrame(JSTracer *trc, const JitFrameIterator &frame)
 {
-    IonJSFrameLayout *layout = (IonJSFrameLayout *)frame.fp();
+    JitFrameLayout *layout = (JitFrameLayout *)frame.fp();
 
     layout->replaceCalleeToken(MarkCalleeToken(trc, layout->calleeToken()));
 
     IonScript *ionScript = nullptr;
     if (frame.checkInvalidation(&ionScript)) {
         // This frame has been invalidated, meaning that its IonScript is no
         // longer reachable through the callee token (JSFunction/JSScript->ion
         // is now nullptr or recompiled). Manually trace it here.
@@ -1049,17 +1049,17 @@ MarkIonJSFrame(JSTracer *trc, const JitF
         }
     }
 #endif
 }
 
 static void
 MarkBailoutFrame(JSTracer *trc, const JitFrameIterator &frame)
 {
-    IonJSFrameLayout *layout = (IonJSFrameLayout *)frame.fp();
+    JitFrameLayout *layout = (JitFrameLayout *)frame.fp();
 
     layout->replaceCalleeToken(MarkCalleeToken(trc, layout->calleeToken()));
 
     // We have to mark the list of actual arguments, as only formal arguments
     // are represented in the Snapshot.
     MarkFrameAndActualArguments(trc, frame);
 
     // Under a bailout, do not have a Safepoint to only iterate over GC-things.
@@ -1090,17 +1090,17 @@ MarkBailoutFrame(JSTracer *trc, const Ji
 #ifdef JSGC_GENERATIONAL
 template <typename T>
 void
 UpdateIonJSFrameForMinorGC(JSTracer *trc, const JitFrameIterator &frame)
 {
     // Minor GCs may move slots/elements allocated in the nursery. Update
     // any slots/elements pointers stored in this frame.
 
-    IonJSFrameLayout *layout = (IonJSFrameLayout *)frame.fp();
+    JitFrameLayout *layout = (JitFrameLayout *)frame.fp();
 
     IonScript *ionScript = nullptr;
     if (frame.checkInvalidation(&ionScript)) {
         // This frame has been invalidated, meaning that its IonScript is no
         // longer reachable through the callee token (JSFunction/JSScript->ion
         // is now nullptr or recompiled).
     } else {
         ionScript = frame.ionScriptFromCalleeToken();
@@ -1141,34 +1141,34 @@ UpdateIonJSFrameForMinorGC(JSTracer *trc
 
 static void
 MarkBaselineStubFrame(JSTracer *trc, const JitFrameIterator &frame)
 {
     // Mark the ICStub pointer stored in the stub frame. This is necessary
     // so that we don't destroy the stub code after unlinking the stub.
 
     MOZ_ASSERT(frame.type() == JitFrame_BaselineStub);
-    IonBaselineStubFrameLayout *layout = (IonBaselineStubFrameLayout *)frame.fp();
+    BaselineStubFrameLayout *layout = (BaselineStubFrameLayout *)frame.fp();
 
     if (ICStub *stub = layout->maybeStubPtr()) {
         MOZ_ASSERT(ICStub::CanMakeCalls(stub->kind()));
         stub->trace(trc);
     }
 }
 
 void
 JitActivationIterator::jitStackRange(uintptr_t *&min, uintptr_t *&end)
 {
     JitFrameIterator frames(*this);
 
     if (frames.isFakeExitFrame()) {
         min = reinterpret_cast<uintptr_t *>(frames.fp());
     } else {
-        IonExitFrameLayout *exitFrame = frames.exitFrame();
-        IonExitFooterFrame *footer = exitFrame->footer();
+        ExitFrameLayout *exitFrame = frames.exitFrame();
+        ExitFooterFrame *footer = exitFrame->footer();
         const VMFunction *f = footer->function();
         if (exitFrame->isWrapperExit() && f->outParam == Type_Handle) {
             switch (f->outParamRootType) {
               case VMFunction::RootNone:
                 MOZ_CRASH("Handle outparam must have root type");
               case VMFunction::RootObject:
               case VMFunction::RootString:
               case VMFunction::RootPropertyName:
@@ -1197,17 +1197,17 @@ uint8_t *
 alignDoubleSpillWithOffset(uint8_t *pointer, int32_t offset)
 {
     uint32_t address = reinterpret_cast<uint32_t>(pointer);
     address = (address - offset) & ~(ABIStackAlignment - 1);
     return reinterpret_cast<uint8_t *>(address);
 }
 
 static void
-MarkJitExitFrameCopiedArguments(JSTracer *trc, const VMFunction *f, IonExitFooterFrame *footer)
+MarkJitExitFrameCopiedArguments(JSTracer *trc, const VMFunction *f, ExitFooterFrame *footer)
 {
     uint8_t *doubleArgs = reinterpret_cast<uint8_t *>(footer);
     doubleArgs = alignDoubleSpillWithOffset(doubleArgs, sizeof(intptr_t));
     if (f->outParam == Type_Handle)
         doubleArgs -= sizeof(Value);
     doubleArgs -= f->doubleByRefArgs() * sizeof(double);
 
     for (uint32_t explicitArg = 0; explicitArg < f->explicitArgs; explicitArg++) {
@@ -1218,43 +1218,43 @@ MarkJitExitFrameCopiedArguments(JSTracer
             else
                 MOZ_ASSERT(f->argRootType(explicitArg) == VMFunction::RootNone);
             doubleArgs += sizeof(double);
         }
     }
 }
 #else
 static void
-MarkJitExitFrameCopiedArguments(JSTracer *trc, const VMFunction *f, IonExitFooterFrame *footer)
+MarkJitExitFrameCopiedArguments(JSTracer *trc, const VMFunction *f, ExitFooterFrame *footer)
 {
     // This is NO-OP on other platforms.
 }
 #endif
 
 static void
 MarkJitExitFrame(JSTracer *trc, const JitFrameIterator &frame)
 {
     // Ignore fake exit frames created by EnsureExitFrame.
     if (frame.isFakeExitFrame())
         return;
 
-    IonExitFooterFrame *footer = frame.exitFrame()->footer();
+    ExitFooterFrame *footer = frame.exitFrame()->footer();
 
     // Mark the code of the code handling the exit path.  This is needed because
     // invalidated script are no longer marked because data are erased by the
     // invalidation and relocation data are no longer reliable.  So the VM
     // wrapper or the invalidation code may be GC if no JitCode keep reference
     // on them.
     MOZ_ASSERT(uintptr_t(footer->jitCode()) != uintptr_t(-1));
 
     // This correspond to the case where we have build a fake exit frame in
     // CodeGenerator.cpp which handle the case of a native function call. We
     // need to mark the argument vector of the function call.
-    if (frame.isExitFrameLayout<IonNativeExitFrameLayout>()) {
-        IonNativeExitFrameLayout *native = frame.exitFrame()->as<IonNativeExitFrameLayout>();
+    if (frame.isExitFrameLayout<NativeExitFrameLayout>()) {
+        NativeExitFrameLayout *native = frame.exitFrame()->as<NativeExitFrameLayout>();
         size_t len = native->argc() + 2;
         Value *vp = native->vp();
         gc::MarkValueRootRange(trc, len, vp, "ion-native-args");
         return;
     }
 
     if (frame.isExitFrameLayout<IonOOLNativeExitFrameLayout>()) {
         IonOOLNativeExitFrameLayout *oolnative =
@@ -1381,17 +1381,17 @@ MarkJitExitFrame(JSTracer *trc, const Ji
 
 static void
 MarkRectifierFrame(JSTracer *trc, const JitFrameIterator &frame)
 {
     // Mark thisv.
     //
     // Baseline JIT code generated as part of the ICCall_Fallback stub may use
     // it if we're calling a constructor that returns a primitive value.
-    IonRectifierFrameLayout *layout = (IonRectifierFrameLayout *)frame.fp();
+    RectifierFrameLayout *layout = (RectifierFrameLayout *)frame.fp();
     gc::MarkValueRoot(trc, &layout->argv()[0], "ion-thisv");
 }
 
 static void
 MarkJitActivation(JSTracer *trc, const JitActivationIterator &activations)
 {
     JitActivation *activation = activations->asJit();
 
@@ -1558,17 +1558,17 @@ uint32_t
 OsiIndex::returnPointDisplacement() const
 {
     // In general, pointer arithmetic on code is bad, but in this case,
     // getting the return address from a call instruction, stepping over pools
     // would be wrong.
     return callPointDisplacement_ + Assembler::PatchWrite_NearCallSize();
 }
 
-RInstructionResults::RInstructionResults(IonJSFrameLayout *fp)
+RInstructionResults::RInstructionResults(JitFrameLayout *fp)
   : results_(nullptr),
     fp_(fp),
     initialized_(false)
 {
 }
 
 RInstructionResults::RInstructionResults(RInstructionResults&& src)
   : results_(mozilla::Move(src.results_)),
@@ -1610,17 +1610,17 @@ RInstructionResults::init(JSContext *cx,
 }
 
 bool
 RInstructionResults::isInitialized() const
 {
     return initialized_;
 }
 
-IonJSFrameLayout *
+JitFrameLayout *
 RInstructionResults::frame() const
 {
     MOZ_ASSERT(fp_);
     return fp_;
 }
 
 RelocatableValue&
 RInstructionResults::operator [](size_t index)
@@ -1633,17 +1633,17 @@ RInstructionResults::trace(JSTracer *trc
 {
     // Note: The vector necessary exists, otherwise this object would not have
     // been stored on the activation from where the trace function is called.
     gc::MarkValueRange(trc, results_->length(), results_->begin(), "ion-recover-results");
 }
 
 
 SnapshotIterator::SnapshotIterator(IonScript *ionScript, SnapshotOffset snapshotOffset,
-                                   IonJSFrameLayout *fp, const MachineState &machine)
+                                   JitFrameLayout *fp, const MachineState &machine)
   : snapshot_(ionScript->snapshots(),
               snapshotOffset,
               ionScript->snapshotsRVATableSize(),
               ionScript->snapshotsListSize()),
     recover_(snapshot_,
              ionScript->recovers(),
              ionScript->recoversSize()),
     fp_(fp),
@@ -1993,17 +1993,17 @@ SnapshotIterator::initInstructionResults
     MOZ_ASSERT(fallback.canRecoverResults());
     JSContext *cx = fallback.maybeCx;
 
     // If there is only one resume point in the list of instructions, then there
     // is no instruction to recover, and thus no need to register any results.
     if (recover_.numInstructions() == 1)
         return true;
 
-    IonJSFrameLayout *fp = fallback.frame->jsFrame();
+    JitFrameLayout *fp = fallback.frame->jsFrame();
     RInstructionResults *results = fallback.activation->maybeIonFrameRecovery(fp);
     if (!results) {
         // We do not have the result yet, which means that an observable stack
         // slot is requested.  As we do not want to bailout every time for the
         // same reason, we need to recompile without optimizing away the
         // observable stack slots.  The script would later be recompiled to have
         // support for Argument objects.
         if (fallback.consequence == MaybeReadFallback::Fallback_Invalidate &&
@@ -2126,24 +2126,24 @@ SnapshotIterator::maybeReadAllocByIndex(
     }
 
     while (moreAllocations())
         skip();
 
     return s;
 }
 
-IonJSFrameLayout *
+JitFrameLayout *
 JitFrameIterator::jsFrame() const
 {
     MOZ_ASSERT(isScripted());
     if (isBailoutJS())
-        return (IonJSFrameLayout *) activation_->bailoutData()->fp();
-
-    return (IonJSFrameLayout *) fp();
+        return (JitFrameLayout *) activation_->bailoutData()->fp();
+
+    return (JitFrameLayout *) fp();
 }
 
 IonScript *
 JitFrameIterator::ionScript() const
 {
     MOZ_ASSERT(isIonScripted());
     if (isBailoutJS())
         return activation_->bailoutData()->ionScript();
@@ -2406,18 +2406,18 @@ JitFrameIterator::isConstructing() const
 }
 
 unsigned
 JitFrameIterator::numActualArgs() const
 {
     if (isScripted())
         return jsFrame()->numActualArgs();
 
-    MOZ_ASSERT(isExitFrameLayout<IonNativeExitFrameLayout>());
-    return exitFrame()->as<IonNativeExitFrameLayout>()->argc();
+    MOZ_ASSERT(isExitFrameLayout<NativeExitFrameLayout>());
+    return exitFrame()->as<NativeExitFrameLayout>()->argc();
 }
 
 void
 SnapshotIterator::warnUnreadableAllocation()
 {
     fprintf(stderr, "Warning! Tried to access unreadable value allocation (possible f.arguments).\n");
 }
 
@@ -2653,27 +2653,27 @@ JitFrameIterator::verifyReturnAddressUsi
                 ++inlineFrames;
         }
     }
 
     return true;
 }
 #endif // DEBUG
 
-IonJSFrameLayout *
+JitFrameLayout *
 InvalidationBailoutStack::fp() const
 {
-    return (IonJSFrameLayout *) (sp() + ionScript_->frameSize());
+    return (JitFrameLayout *) (sp() + ionScript_->frameSize());
 }
 
 void
 InvalidationBailoutStack::checkInvariants() const
 {
 #ifdef DEBUG
-    IonJSFrameLayout *frame = fp();
+    JitFrameLayout *frame = fp();
     CalleeToken token = frame->calleeToken();
     MOZ_ASSERT(token);
 
     uint8_t *rawBase = ionScript()->method()->raw();
     uint8_t *rawLimit = rawBase + ionScript()->method()->instructionsSize();
     uint8_t *osiPoint = osiPointReturnAddress();
     MOZ_ASSERT(rawBase <= osiPoint && osiPoint <= rawLimit);
 #endif
rename from js/src/jit/IonFrames.h
rename to js/src/jit/JitFrames.h
--- a/js/src/jit/IonFrames.h
+++ b/js/src/jit/JitFrames.h
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef jit_IonFrames_h
-#define jit_IonFrames_h
+#ifndef jit_JitFrames_h
+#define jit_JitFrames_h
 
 #include <stdint.h>
 
 #include "jscntxt.h"
 #include "jsfun.h"
 
 #include "jit/JitFrameIterator.h"
 
@@ -266,17 +266,17 @@ struct ResumeFromException
     Value exception;
 
     BaselineBailoutInfo *bailoutInfo;
 };
 
 void HandleException(ResumeFromException *rfe);
 void HandleParallelFailure(ResumeFromException *rfe);
 
-void EnsureExitFrame(IonCommonFrameLayout *frame);
+void EnsureExitFrame(CommonFrameLayout *frame);
 
 void MarkJitActivations(PerThreadData *ptd, JSTracer *trc);
 void MarkIonCompilerRoots(JSTracer *trc);
 
 JSCompartment *
 TopmostIonActivationCompartment(JSRuntime *rt);
 
 #ifdef JSGC_GENERATIONAL
@@ -285,19 +285,19 @@ void UpdateJitActivationsForMinorGC(PerT
 #endif
 
 static inline uint32_t
 MakeFrameDescriptor(uint32_t frameSize, FrameType type)
 {
     return (frameSize << FRAMESIZE_SHIFT) | type;
 }
 
-// Returns the JSScript associated with the topmost Ion frame.
+// Returns the JSScript associated with the topmost JIT frame.
 inline JSScript *
-GetTopIonJSScript(ThreadSafeContext *cx, void **returnAddrOut = nullptr)
+GetTopJitJSScript(ThreadSafeContext *cx, void **returnAddrOut = nullptr)
 {
     JitFrameIterator iter(cx);
     MOZ_ASSERT(iter.type() == JitFrame_Exit);
     ++iter;
 
     MOZ_ASSERT(iter.returnAddressToFp() != nullptr);
     if (returnAddrOut)
         *returnAddrOut = (void *) iter.returnAddressToFp();
@@ -319,29 +319,29 @@ alignDoubleSpillWithOffset(uint8_t *poin
 {
     // This is NO-OP on non-MIPS platforms.
     return pointer;
 }
 #endif
 
 // Layout of the frame prefix. This assumes the stack architecture grows down.
 // If this is ever not the case, we'll have to refactor.
-class IonCommonFrameLayout
+class CommonFrameLayout
 {
     uint8_t *returnAddress_;
     uintptr_t descriptor_;
 
     static const uintptr_t FrameTypeMask = (1 << FRAMETYPE_BITS) - 1;
 
   public:
     static size_t offsetOfDescriptor() {
-        return offsetof(IonCommonFrameLayout, descriptor_);
+        return offsetof(CommonFrameLayout, descriptor_);
     }
     static size_t offsetOfReturnAddress() {
-        return offsetof(IonCommonFrameLayout, returnAddress_);
+        return offsetof(CommonFrameLayout, returnAddress_);
     }
     FrameType prevType() const {
         return FrameType(descriptor_ & FrameTypeMask);
     }
     void changePrevType(FrameType type) {
         descriptor_ &= ~FrameTypeMask;
         descriptor_ |= type;
     }
@@ -354,41 +354,41 @@ class IonCommonFrameLayout
     uint8_t *returnAddress() const {
         return returnAddress_;
     }
     void setReturnAddress(uint8_t *addr) {
         returnAddress_ = addr;
     }
 };
 
-class IonJSFrameLayout : public IonCommonFrameLayout
+class JitFrameLayout : public CommonFrameLayout
 {
     CalleeToken calleeToken_;
     uintptr_t numActualArgs_;
 
   public:
     CalleeToken calleeToken() const {
         return calleeToken_;
     }
     void replaceCalleeToken(CalleeToken calleeToken) {
         calleeToken_ = calleeToken;
     }
 
     static size_t offsetOfCalleeToken() {
-        return offsetof(IonJSFrameLayout, calleeToken_);
+        return offsetof(JitFrameLayout, calleeToken_);
     }
     static size_t offsetOfNumActualArgs() {
-        return offsetof(IonJSFrameLayout, numActualArgs_);
+        return offsetof(JitFrameLayout, numActualArgs_);
     }
     static size_t offsetOfThis() {
-        IonJSFrameLayout *base = nullptr;
+        JitFrameLayout *base = nullptr;
         return reinterpret_cast<size_t>(&base->argv()[0]);
     }
     static size_t offsetOfActualArgs() {
-        IonJSFrameLayout *base = nullptr;
+        JitFrameLayout *base = nullptr;
         // +1 to skip |this|.
         return reinterpret_cast<size_t>(&base->argv()[1]);
     }
     static size_t offsetOfActualArg(size_t arg) {
         return offsetOfActualArgs() + arg * sizeof(Value);
     }
 
     Value thisv() {
@@ -403,58 +403,58 @@ class IonJSFrameLayout : public IonCommo
 
     // Computes a reference to a slot, where a slot is a distance from the base
     // frame pointer (as would be used for LStackSlot).
     uintptr_t *slotRef(uint32_t slot) {
         return (uintptr_t *)((uint8_t *)this - slot);
     }
 
     static inline size_t Size() {
-        return sizeof(IonJSFrameLayout);
+        return sizeof(JitFrameLayout);
     }
 };
 
 // this is the layout of the frame that is used when we enter Ion code from platform ABI code
-class IonEntryFrameLayout : public IonJSFrameLayout
+class EntryFrameLayout : public JitFrameLayout
 {
   public:
     static inline size_t Size() {
-        return sizeof(IonEntryFrameLayout);
+        return sizeof(EntryFrameLayout);
     }
 };
 
-class IonRectifierFrameLayout : public IonJSFrameLayout
+class RectifierFrameLayout : public JitFrameLayout
 {
   public:
     static inline size_t Size() {
-        return sizeof(IonRectifierFrameLayout);
+        return sizeof(RectifierFrameLayout);
     }
 };
 
 // The callee token is now dead.
-class IonUnwoundRectifierFrameLayout : public IonRectifierFrameLayout
+class IonUnwoundRectifierFrameLayout : public RectifierFrameLayout
 {
   public:
     static inline size_t Size() {
         // It is not necessary to accout for an extra callee token here because
-        // sizeof(IonExitFrameLayout) == sizeof(IonRectifierFrameLayout) due to
+        // sizeof(ExitFrameLayout) == sizeof(RectifierFrameLayout) due to
         // extra padding.
         return sizeof(IonUnwoundRectifierFrameLayout);
     }
 };
 
 // GC related data used to keep alive data surrounding the Exit frame.
-class IonExitFooterFrame
+class ExitFooterFrame
 {
     const VMFunction *function_;
     JitCode *jitCode_;
 
   public:
     static inline size_t Size() {
-        return sizeof(IonExitFooterFrame);
+        return sizeof(ExitFooterFrame);
     }
     inline JitCode *jitCode() const {
         return jitCode_;
     }
     inline JitCode **addressOfJitCode() {
         return &jitCode_;
     }
     inline const VMFunction *function() const {
@@ -465,44 +465,44 @@ class IonExitFooterFrame
     template <typename T>
     T *outParam() {
         uint8_t *address = reinterpret_cast<uint8_t *>(this);
         address = alignDoubleSpillWithOffset(address, sizeof(intptr_t));
         return reinterpret_cast<T *>(address - sizeof(T));
     }
 };
 
-class IonNativeExitFrameLayout;
+class NativeExitFrameLayout;
 class IonOOLNativeExitFrameLayout;
 class IonOOLPropertyOpExitFrameLayout;
 class IonOOLProxyExitFrameLayout;
 class IonDOMExitFrameLayout;
 
 // this is the frame layout when we are exiting ion code, and about to enter platform ABI code
-class IonExitFrameLayout : public IonCommonFrameLayout
+class ExitFrameLayout : public CommonFrameLayout
 {
     inline uint8_t *top() {
         return reinterpret_cast<uint8_t *>(this + 1);
     }
 
   public:
     // Pushed for "bare" fake exit frames that have no GC things on stack to be
     // marked.
     static JitCode *BareToken() { return (JitCode *)0xFF; }
 
     static inline size_t Size() {
-        return sizeof(IonExitFrameLayout);
+        return sizeof(ExitFrameLayout);
     }
     static inline size_t SizeWithFooter() {
-        return Size() + IonExitFooterFrame::Size();
+        return Size() + ExitFooterFrame::Size();
     }
 
-    inline IonExitFooterFrame *footer() {
+    inline ExitFooterFrame *footer() {
         uint8_t *sp = reinterpret_cast<uint8_t *>(this);
-        return reinterpret_cast<IonExitFooterFrame *>(sp - IonExitFooterFrame::Size());
+        return reinterpret_cast<ExitFooterFrame *>(sp - ExitFooterFrame::Size());
     }
 
     // argBase targets the point which precedes the exit frame. Arguments of VM
     // each wrapper are pushed before the exit frame.  This correspond exactly
     // to the value of the argBase register of the generateVMWrapper function.
     inline uint8_t *argBase() {
         MOZ_ASSERT(footer()->jitCode() != nullptr);
         return top();
@@ -521,52 +521,52 @@ class IonExitFrameLayout : public IonCom
     }
     template <typename T> inline T *as() {
         MOZ_ASSERT(this->is<T>());
         return reinterpret_cast<T *>(footer());
     }
 };
 
 // Cannot inherit implementation since we need to extend the top of
-// IonExitFrameLayout.
-class IonNativeExitFrameLayout
+// ExitFrameLayout.
+class NativeExitFrameLayout
 {
   protected: // only to silence a clang warning about unused private fields
-    IonExitFooterFrame footer_;
-    IonExitFrameLayout exit_;
+    ExitFooterFrame footer_;
+    ExitFrameLayout exit_;
     uintptr_t argc_;
 
     // We need to split the Value into 2 fields of 32 bits, otherwise the C++
     // compiler may add some padding between the fields.
     uint32_t loCalleeResult_;
     uint32_t hiCalleeResult_;
 
   public:
     static JitCode *Token() { return (JitCode *)0x0; }
 
     static inline size_t Size() {
-        return sizeof(IonNativeExitFrameLayout);
+        return sizeof(NativeExitFrameLayout);
     }
 
     static size_t offsetOfResult() {
-        return offsetof(IonNativeExitFrameLayout, loCalleeResult_);
+        return offsetof(NativeExitFrameLayout, loCalleeResult_);
     }
     inline Value *vp() {
         return reinterpret_cast<Value*>(&loCalleeResult_);
     }
     inline uintptr_t argc() const {
         return argc_;
     }
 };
 
 class IonOOLNativeExitFrameLayout
 {
   protected: // only to silence a clang warning about unused private fields
-    IonExitFooterFrame footer_;
-    IonExitFrameLayout exit_;
+    ExitFooterFrame footer_;
+    ExitFrameLayout exit_;
 
     // pointer to root the stub's JitCode
     JitCode *stubCode_;
 
     uintptr_t argc_;
 
     // We need to split the Value into 2 fields of 32 bits, otherwise the C++
     // compiler may add some padding between the fields.
@@ -601,18 +601,18 @@ class IonOOLNativeExitFrameLayout
     inline uintptr_t argc() const {
         return argc_;
     }
 };
 
 class IonOOLPropertyOpExitFrameLayout
 {
   protected: // only to silence a clang warning about unused private fields
-    IonExitFooterFrame footer_;
-    IonExitFrameLayout exit_;
+    ExitFooterFrame footer_;
+    ExitFrameLayout exit_;
 
     // Object for HandleObject
     JSObject *obj_;
 
     // id for HandleId
     jsid id_;
 
     // space for MutableHandleValue result
@@ -650,18 +650,18 @@ class IonOOLPropertyOpExitFrameLayout
 
 // Proxy::get(JSContext *cx, HandleObject proxy, HandleObject receiver, HandleId id,
 //            MutableHandleValue vp)
 // Proxy::set(JSContext *cx, HandleObject proxy, HandleObject receiver, HandleId id,
 //            bool strict, MutableHandleValue vp)
 class IonOOLProxyExitFrameLayout
 {
   protected: // only to silence a clang warning about unused private fields
-    IonExitFooterFrame footer_;
-    IonExitFrameLayout exit_;
+    ExitFooterFrame footer_;
+    ExitFrameLayout exit_;
 
     // The proxy object.
     JSObject *proxy_;
 
     // Object for HandleObject
     JSObject *receiver_;
 
     // id for HandleId
@@ -701,18 +701,18 @@ class IonOOLProxyExitFrameLayout
     inline JSObject **proxy() {
         return &proxy_;
     }
 };
 
 class IonDOMExitFrameLayout
 {
   protected: // only to silence a clang warning about unused private fields
-    IonExitFooterFrame footer_;
-    IonExitFrameLayout exit_;
+    ExitFooterFrame footer_;
+    ExitFrameLayout exit_;
     JSObject *thisObj;
 
     // We need to split the Value into 2 fields of 32 bits, otherwise the C++
     // compiler may add some padding between the fields.
     uint32_t loCalleeResult_;
     uint32_t hiCalleeResult_;
 
   public:
@@ -735,18 +735,18 @@ class IonDOMExitFrameLayout
     inline bool isMethodFrame();
 };
 
 struct IonDOMMethodExitFrameLayoutTraits;
 
 class IonDOMMethodExitFrameLayout
 {
   protected: // only to silence a clang warning about unused private fields
-    IonExitFooterFrame footer_;
-    IonExitFrameLayout exit_;
+    ExitFooterFrame footer_;
+    ExitFrameLayout exit_;
     // This must be the last thing pushed, so as to stay common with
     // IonDOMExitFrameLayout.
     JSObject *thisObj_;
     Value *argv_;
     uintptr_t argc_;
 
     // We need to split the Value into 2 fields of 32 bits, otherwise the C++
     // compiler may add some padding between the fields.
@@ -783,46 +783,46 @@ class IonDOMMethodExitFrameLayout
 inline bool
 IonDOMExitFrameLayout::isMethodFrame()
 {
     return footer_.jitCode() == IonDOMMethodExitFrameLayout::Token();
 }
 
 template <>
 inline bool
-IonExitFrameLayout::is<IonDOMExitFrameLayout>()
+ExitFrameLayout::is<IonDOMExitFrameLayout>()
 {
     JitCode *code = footer()->jitCode();
     return
         code == IonDOMExitFrameLayout::GetterToken() ||
         code == IonDOMExitFrameLayout::SetterToken() ||
         code == IonDOMMethodExitFrameLayout::Token();
 }
 
 template <>
 inline IonDOMExitFrameLayout *
-IonExitFrameLayout::as<IonDOMExitFrameLayout>()
+ExitFrameLayout::as<IonDOMExitFrameLayout>()
 {
     MOZ_ASSERT(is<IonDOMExitFrameLayout>());
     return reinterpret_cast<IonDOMExitFrameLayout *>(footer());
 }
 
 struct IonDOMMethodExitFrameLayoutTraits {
     static const size_t offsetOfArgcFromArgv =
         offsetof(IonDOMMethodExitFrameLayout, argc_) -
         offsetof(IonDOMMethodExitFrameLayout, argv_);
 };
 
 class ICStub;
 
-class IonBaselineStubFrameLayout : public IonCommonFrameLayout
+class BaselineStubFrameLayout : public CommonFrameLayout
 {
   public:
     static inline size_t Size() {
-        return sizeof(IonBaselineStubFrameLayout);
+        return sizeof(BaselineStubFrameLayout);
     }
 
     static inline int reverseOffsetOfStubPtr() {
         return -int(sizeof(void *));
     }
     static inline int reverseOffsetOfSavedFramePtr() {
         return -int(2 * sizeof(void *));
     }
@@ -844,17 +844,17 @@ class InvalidationBailoutStack
     mozilla::Array<uintptr_t, Registers::Total> regs_;
     IonScript   *ionScript_;
     uint8_t       *osiPointReturnAddress_;
 
   public:
     uint8_t *sp() const {
         return (uint8_t *) this + sizeof(InvalidationBailoutStack);
     }
-    IonJSFrameLayout *fp() const;
+    JitFrameLayout *fp() const;
     MachineState machine() {
         return MachineState::FromBailout(regs_, fpregs_);
     }
 
     IonScript *ionScript() const {
         return ionScript_;
     }
     uint8_t *osiPointReturnAddress() const {
@@ -874,9 +874,9 @@ void
 GetPcScript(JSContext *cx, JSScript **scriptRes, jsbytecode **pcRes);
 
 CalleeToken
 MarkCalleeToken(JSTracer *trc, CalleeToken token);
 
 } /* namespace jit */
 } /* namespace js */
 
-#endif /* jit_IonFrames_h */
+#endif /* jit_JitFrames_h */
--- a/js/src/jit/JitSpewer.cpp
+++ b/js/src/jit/JitSpewer.cpp
@@ -77,38 +77,38 @@ jit::EnableIonDebugLogging()
 {
     EnableChannel(JitSpew_IonLogs);
     ionspewer.init();
 }
 
 void
 jit::IonSpewNewFunction(MIRGraph *graph, HandleScript func)
 {
-    if (GetIonContext()->runtime->onMainThread())
+    if (GetJitContext()->runtime->onMainThread())
         ionspewer.beginFunction(graph, func);
 }
 
 void
 jit::IonSpewPass(const char *pass)
 {
-    if (GetIonContext()->runtime->onMainThread())
+    if (GetJitContext()->runtime->onMainThread())
         ionspewer.spewPass(pass);
 }
 
 void
 jit::IonSpewPass(const char *pass, LinearScanAllocator *ra)
 {
-    if (GetIonContext()->runtime->onMainThread())
+    if (GetJitContext()->runtime->onMainThread())
         ionspewer.spewPass(pass, ra);
 }
 
 void
 jit::IonSpewEndFunction()
 {
-    if (GetIonContext()->runtime->onMainThread())
+    if (GetJitContext()->runtime->onMainThread())
         ionspewer.endFunction();
 }
 
 
 IonSpewer::~IonSpewer()
 {
     if (!inited_)
         return;
--- a/js/src/jit/LIR-Common.h
+++ b/js/src/jit/LIR-Common.h
@@ -95,17 +95,17 @@ class LMove
     }
     LDefinition::Type type() const {
         return type_;
     }
 };
 
 class LMoveGroup : public LInstructionHelper<0, 0, 0>
 {
-    js::Vector<LMove, 2, IonAllocPolicy> moves_;
+    js::Vector<LMove, 2, JitAllocPolicy> moves_;
 
     explicit LMoveGroup(TempAllocator &alloc)
       : moves_(alloc)
     { }
 
   public:
     LIR_HEADER(MoveGroup)
 
--- a/js/src/jit/LIR.h
+++ b/js/src/jit/LIR.h
@@ -9,17 +9,17 @@
 
 // This file declares the core data structures for LIR: storage allocations for
 // inputs and outputs, as well as the interface instructions must conform to.
 
 #include "mozilla/Array.h"
 
 #include "jit/Bailouts.h"
 #include "jit/InlineList.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/LOpcodes.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/Registers.h"
 #include "jit/Safepoints.h"
 
 namespace js {
 namespace jit {
@@ -1060,17 +1060,17 @@ class LCallInstructionHelper : public LI
     virtual bool isCall() const {
         return true;
     }
 };
 
 class LRecoverInfo : public TempObject
 {
   public:
-    typedef Vector<MNode *, 2, IonAllocPolicy> Instructions;
+    typedef Vector<MNode *, 2, JitAllocPolicy> Instructions;
 
   private:
     // List of instructions needed to recover the stack frames.
     // Outer frames are stored before inner frames.
     Instructions instructions_;
 
     // Cached offset where this resume point is encoded.
     RecoverOffset recoverOffset_;
@@ -1245,18 +1245,18 @@ struct SafepointNunboxEntry {
     { }
 };
 
 class LSafepoint : public TempObject
 {
     typedef SafepointNunboxEntry NunboxEntry;
 
   public:
-    typedef Vector<uint32_t, 0, IonAllocPolicy> SlotList;
-    typedef Vector<NunboxEntry, 0, IonAllocPolicy> NunboxList;
+    typedef Vector<uint32_t, 0, JitAllocPolicy> SlotList;
+    typedef Vector<NunboxEntry, 0, JitAllocPolicy> NunboxList;
 
   private:
     // The information in a safepoint describes the registers and gc related
     // values that are live at the start of the associated instruction.
 
     // The set of registers which are live at an OOL call made within the
     // instruction. This includes any registers for inputs which are not
     // use-at-start, any registers for temps, and any registers live after the
@@ -1651,21 +1651,21 @@ class LIRGraph
             return HashNumber(v.asRawBits());
         }
         static bool match(const Value &lhs, const Value &rhs) {
             return lhs == rhs;
         }
     };
 
     FixedList<LBlock> blocks_;
-    Vector<Value, 0, IonAllocPolicy> constantPool_;
-    typedef HashMap<Value, uint32_t, ValueHasher, IonAllocPolicy> ConstantPoolMap;
+    Vector<Value, 0, JitAllocPolicy> constantPool_;
+    typedef HashMap<Value, uint32_t, ValueHasher, JitAllocPolicy> ConstantPoolMap;
     ConstantPoolMap constantPoolMap_;
-    Vector<LInstruction *, 0, IonAllocPolicy> safepoints_;
-    Vector<LInstruction *, 0, IonAllocPolicy> nonCallSafepoints_;
+    Vector<LInstruction *, 0, JitAllocPolicy> safepoints_;
+    Vector<LInstruction *, 0, JitAllocPolicy> nonCallSafepoints_;
     uint32_t numVirtualRegisters_;
     uint32_t numInstructions_;
 
     // Number of stack slots needed for local spills.
     uint32_t localSlotCount_;
     // Number of stack slots needed for argument construction for calls.
     uint32_t argumentSlotCount_;
 
--- a/js/src/jit/Label.h
+++ b/js/src/jit/Label.h
@@ -78,17 +78,17 @@ class Label : public LabelBase
 {
   public:
     ~Label()
     {
 #ifdef DEBUG
         // The assertion below doesn't hold if an error occurred.
         if (OOM_counter > OOM_maxAllocations)
             return;
-        if (IonContext *context = MaybeGetIonContext()) {
+        if (JitContext *context = MaybeGetJitContext()) {
             if (context->runtime->hadOutOfMemory())
                 return;
         }
 
         MOZ_ASSERT(!used());
 #endif
     }
 };
rename from js/src/jit/IonLinker.h
rename to js/src/jit/Linker.h
--- a/js/src/jit/IonLinker.h
+++ b/js/src/jit/Linker.h
@@ -1,25 +1,25 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef jit_IonLinker_h
-#define jit_IonLinker_h
+#ifndef jit_Linker_h
+#define jit_Linker_h
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 #include "jsgc.h"
 
 #include "jit/ExecutableAllocator.h"
 #include "jit/IonCode.h"
-#include "jit/IonMacroAssembler.h"
 #include "jit/JitCompartment.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 class Linker
 {
     MacroAssembler &masm;
 
@@ -88,9 +88,9 @@ class Linker
 
         return newCode<CanGC>(cx, alloc, ION_CODE);
     }
 };
 
 } // namespace jit
 } // namespace js
 
-#endif /* jit_IonLinker_h */
+#endif /* jit_Linker_h */
--- a/js/src/jit/LiveRangeAllocator.h
+++ b/js/src/jit/LiveRangeAllocator.h
@@ -255,17 +255,17 @@ class LiveInterval
 
         // Return a string describing this range. This is not re-entrant!
         const char *toString() const;
 
         void dump() const;
     };
 
   private:
-    Vector<Range, 1, IonAllocPolicy> ranges_;
+    Vector<Range, 1, JitAllocPolicy> ranges_;
     LAllocation alloc_;
     LiveInterval *spillInterval_;
     uint32_t vreg_;
     uint32_t index_;
     Requirement requirement_;
     Requirement hint_;
     InlineForwardList<UsePosition> uses_;
     size_t lastProcessedRange_;
@@ -423,17 +423,17 @@ class LiveInterval
  * Represents all of the register allocation state associated with a virtual
  * register, including all associated intervals and pointers to relevant LIR
  * structures.
  */
 class VirtualRegister
 {
     LNode *ins_;
     LDefinition *def_;
-    Vector<LiveInterval *, 1, IonAllocPolicy> intervals_;
+    Vector<LiveInterval *, 1, JitAllocPolicy> intervals_;
 
     // Whether def_ is a temp or an output.
     bool isTemp_ : 1;
 
     void operator=(const VirtualRegister &) MOZ_DELETE;
     VirtualRegister(const VirtualRegister &) MOZ_DELETE;
 
   protected:
--- a/js/src/jit/Lowering.cpp
+++ b/js/src/jit/Lowering.cpp
@@ -1991,23 +1991,23 @@ LIRGenerator::visitTruncateToInt32(MTrun
 
 bool
 LIRGenerator::visitToString(MToString *ins)
 {
     MDefinition *opd = ins->input();
 
     switch (opd->type()) {
       case MIRType_Null: {
-        const JSAtomState &names = GetIonContext()->runtime->names();
+        const JSAtomState &names = GetJitContext()->runtime->names();
         LPointer *lir = new(alloc()) LPointer(names.null);
         return define(lir, ins);
       }
 
       case MIRType_Undefined: {
-        const JSAtomState &names = GetIonContext()->runtime->names();
+        const JSAtomState &names = GetJitContext()->runtime->names();
         LPointer *lir = new(alloc()) LPointer(names.undefined);
         return define(lir, ins);
       }
 
       case MIRType_Boolean: {
         LBooleanToString *lir = new(alloc()) LBooleanToString(useRegister(opd));
         return define(lir, ins);
       }
@@ -2308,17 +2308,17 @@ LIRGenerator::visitGuardThreadExclusive(
     lir->setMir(ins);
     return assignSnapshot(lir, Bailout_GuardThreadExclusive) && add(lir, ins);
 }
 
 bool
 LIRGenerator::visitInterruptCheck(MInterruptCheck *ins)
 {
     // Implicit interrupt checks require asm.js signal handlers to be installed.
-    if (GetIonContext()->runtime->canUseSignalHandlers()) {
+    if (GetJitContext()->runtime->canUseSignalHandlers()) {
         LInterruptCheckImplicit *lir = new(alloc()) LInterruptCheckImplicit();
         return add(lir, ins) && assignSafepoint(lir, ins);
     }
 
     LInterruptCheck *lir = new(alloc()) LInterruptCheck();
     return add(lir, ins) && assignSafepoint(lir, ins);
 }
 
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -1458,17 +1458,17 @@ IonBuilder::inlineRegExpExec(CallInfo &c
     types::TemporaryTypeSet *thisTypes = callInfo.thisArg()->resultTypeSet();
     const Class *clasp = thisTypes ? thisTypes->getKnownClass() : nullptr;
     if (clasp != &RegExpObject::class_)
         return InliningStatus_NotInlined;
 
     if (callInfo.getArg(0)->mightBeType(MIRType_Object))
         return InliningStatus_NotInlined;
 
-    JSContext *cx = GetIonContext()->cx;
+    JSContext *cx = GetJitContext()->cx;
     if (!cx->compartment()->jitCompartment()->ensureRegExpExecStubExists(cx))
         return InliningStatus_Error;
 
     callInfo.setImplicitlyUsedUnchecked();
 
     MInstruction *exec = MRegExpExec::New(alloc(), callInfo.thisArg(), callInfo.getArg(0));
     current->add(exec);
     current->push(exec);
@@ -1496,17 +1496,17 @@ IonBuilder::inlineRegExpTest(CallInfo &c
         return InliningStatus_NotInlined;
     types::TemporaryTypeSet *thisTypes = callInfo.thisArg()->resultTypeSet();
     const Class *clasp = thisTypes ? thisTypes->getKnownClass() : nullptr;
     if (clasp != &RegExpObject::class_)
         return InliningStatus_NotInlined;
     if (callInfo.getArg(0)->mightBeType(MIRType_Object))
         return InliningStatus_NotInlined;
 
-    JSContext *cx = GetIonContext()->cx;
+    JSContext *cx = GetJitContext()->cx;
     if (!cx->compartment()->jitCompartment()->ensureRegExpTestStubExists(cx))
         return InliningStatus_Error;
 
     callInfo.setImplicitlyUsedUnchecked();
 
     MInstruction *match = MRegExpTest::New(alloc(), callInfo.thisArg(), callInfo.getArg(0));
     current->add(match);
     current->push(match);
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -602,24 +602,24 @@ jit::MakeSingletonTypeSet(types::Compile
     // Invalidate when this object's TypeObject gets unknown properties. This
     // happens for instance when we mutate an object's __proto__, in this case
     // we want to invalidate and mark this TypeSet as containing AnyObject
     // (because mutating __proto__ will change an object's TypeObject).
     MOZ_ASSERT(constraints);
     types::TypeObjectKey *objType = types::TypeObjectKey::get(obj);
     objType->hasFlags(constraints, types::OBJECT_FLAG_UNKNOWN_PROPERTIES);
 
-    LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+    LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
     return alloc->new_<types::TemporaryTypeSet>(alloc, types::Type::ObjectType(obj));
 }
 
 static types::TemporaryTypeSet *
 MakeUnknownTypeSet()
 {
-    LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+    LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
     return alloc->new_<types::TemporaryTypeSet>(alloc, types::Type::UnknownType());
 }
 
 MConstant::MConstant(const js::Value &vp, types::CompilerConstraintList *constraints)
   : value_(vp)
 {
     setResultType(MIRTypeFromValue(vp));
     if (vp.isObject()) {
@@ -871,17 +871,17 @@ MLoadTypedArrayElement::printOpcode(FILE
     MDefinition::printOpcode(fp);
     fprintf(fp, " %s", ScalarTypeDescr::typeName(arrayType()));
 }
 
 void
 MAssertRange::printOpcode(FILE *fp) const
 {
     MDefinition::printOpcode(fp);
-    Sprinter sp(GetIonContext()->cx);
+    Sprinter sp(GetJitContext()->cx);
     sp.init();
     assertedRange()->print(sp);
     fprintf(fp, " %s", sp.string());
 }
 
 const char *
 MMathFunction::FunctionName(Function function)
 {
@@ -1337,17 +1337,17 @@ MPhi::foldsTernary()
             c->block()->moveBefore(pred->lastIns(), c);
         return trueDef;
     }
 
     // If testArg is a string type we can:
     // - fold testArg ? testArg : "" to testArg
     // - fold testArg ? "" : testArg to ""
     if (testArg->type() == MIRType_String &&
-        c->vp()->toString() == GetIonContext()->runtime->emptyString())
+        c->vp()->toString() == GetJitContext()->runtime->emptyString())
     {
         // When folding to the constant we need to hoist it.
         if (trueDef == c && !c->block()->dominates(block()))
             c->block()->moveBefore(pred->lastIns(), c);
         return trueDef;
     }
 
     return nullptr;
@@ -1414,17 +1414,17 @@ MPhi::congruentTo(const MDefinition *ins
 
 static inline types::TemporaryTypeSet *
 MakeMIRTypeSet(MIRType type)
 {
     MOZ_ASSERT(type != MIRType_Value);
     types::Type ntype = type == MIRType_Object
                         ? types::Type::AnyObjectType()
                         : types::Type::PrimitiveType(ValueTypeFromMIRType(type));
-    LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+    LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
     return alloc->new_<types::TemporaryTypeSet>(alloc, ntype);
 }
 
 bool
 jit::MergeTypes(MIRType *ptype, types::TemporaryTypeSet **ptypeSet,
                 MIRType newType, types::TemporaryTypeSet *newTypeSet)
 {
     if (newTypeSet && newTypeSet->empty())
@@ -1439,17 +1439,17 @@ jit::MergeTypes(MIRType *ptype, types::T
                     return false;
             }
             *ptype = MIRType_Value;
         } else if (*ptypeSet && (*ptypeSet)->empty()) {
             *ptype = newType;
         }
     }
     if (*ptypeSet) {
-        LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+        LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
         if (!newTypeSet && newType != MIRType_Value) {
             newTypeSet = MakeMIRTypeSet(newType);
             if (!newTypeSet)
                 return false;
         }
         if (newTypeSet) {
             if (!newTypeSet->isSubset(*ptypeSet))
                 *ptypeSet = types::TypeSet::unionSets(*ptypeSet, newTypeSet, alloc);
@@ -2228,17 +2228,17 @@ MBinaryArithInstruction::inferFallback(B
         setResultType(MIRType_Double);
         return;
     }
 
     // If we can't specialize because we have no type information at all for
     // the lhs or rhs, mark the binary instruction as having no possible types
     // either to avoid degrading subsequent analysis.
     if (getOperand(0)->emptyResultTypeSet() || getOperand(1)->emptyResultTypeSet()) {
-        LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+        LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
         types::TemporaryTypeSet *types = alloc->new_<types::TemporaryTypeSet>();
         if (types)
             setResultTypeSet(types);
     }
 }
 
 static bool
 SafelyCoercesToDouble(MDefinition *op)
@@ -2580,17 +2580,17 @@ MTypeOf::foldsTo(TempAllocator &alloc)
             type = JSTYPE_OBJECT;
             break;
         }
         // FALL THROUGH
       default:
         return this;
     }
 
-    return MConstant::New(alloc, StringValue(TypeName(type, GetIonContext()->runtime->names())));
+    return MConstant::New(alloc, StringValue(TypeName(type, GetJitContext()->runtime->names())));
 }
 
 void
 MTypeOf::cacheInputMaybeCallableOrEmulatesUndefined()
 {
     MOZ_ASSERT(inputMaybeCallableOrEmulatesUndefined());
 
     if (!MaybeEmulatesUndefined(input()) && !MaybeCallable(input()))
@@ -3348,17 +3348,17 @@ MNot::trySpecializeFloat32(TempAllocator
         ConvertDefinitionToDouble<0>(alloc, in, this);
 }
 
 void
 MBeta::printOpcode(FILE *fp) const
 {
     MDefinition::printOpcode(fp);
 
-    if (IonContext *context = MaybeGetIonContext()) {
+    if (JitContext *context = MaybeGetJitContext()) {
         Sprinter sp(context->cx);
         sp.init();
         comparison_->print(sp);
         fprintf(fp, " %s", sp.string());
     } else {
         fprintf(fp, " ???");
     }
 }
@@ -3705,17 +3705,17 @@ InlinePropertyTable::hasFunction(JSFunct
             return true;
     }
     return false;
 }
 
 types::TemporaryTypeSet *
 InlinePropertyTable::buildTypeSetForFunction(JSFunction *func) const
 {
-    LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+    LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
     types::TemporaryTypeSet *types = alloc->new_<types::TemporaryTypeSet>();
     if (!types)
         return nullptr;
     for (size_t i = 0; i < numEntries(); i++) {
         if (entries_[i]->func == func)
             types->addType(types::Type::ObjectType(entries_[i]->typeObj), alloc);
     }
     return types;
@@ -4108,17 +4108,17 @@ jit::PropertyReadNeedsTypeBarrier(JSCont
             if (!typeObj->unknownProperties()) {
                 types::HeapTypeSetKey property = typeObj->property(NameToId(name));
                 if (property.maybeTypes()) {
                     types::TypeSet::TypeList types;
                     if (!property.maybeTypes()->enumerateTypes(&types))
                         break;
                     if (types.length()) {
                         // Note: the return value here is ignored.
-                        observed->addType(types[0], GetIonContext()->temp->lifoAlloc());
+                        observed->addType(types[0], GetJitContext()->temp->lifoAlloc());
                         break;
                     }
                 }
             }
 
             if (!obj->hasTenuredProto())
                 break;
             obj = obj->getProto();
@@ -4232,17 +4232,17 @@ jit::PropertyReadIsIdempotent(types::Com
 
 void
 jit::AddObjectsForPropertyRead(MDefinition *obj, PropertyName *name,
                                types::TemporaryTypeSet *observed)
 {
     // Add objects to observed which *could* be observed by reading name from obj,
     // to hopefully avoid unnecessary type barriers and code invalidations.
 
-    LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
+    LifoAlloc *alloc = GetJitContext()->temp->lifoAlloc();
 
     types::TemporaryTypeSet *types = obj->resultTypeSet();
     if (!types || types->unknownObject()) {
         observed->addType(types::Type::AnyObjectType(), alloc);
         return;
     }
 
     for (size_t i = 0; i < types->getObjectCount(); i++) {
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -13,18 +13,18 @@
 #define jit_MIR_h
 
 #include "mozilla/Array.h"
 #include "mozilla/DebugOnly.h"
 
 #include "jit/AtomicOp.h"
 #include "jit/FixedList.h"
 #include "jit/InlineList.h"
-#include "jit/IonAllocPolicy.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/JitAllocPolicy.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MOpcodes.h"
 #include "jit/TypedObjectPrediction.h"
 #include "jit/TypePolicy.h"
 #include "vm/ArrayObject.h"
 #include "vm/ScopeObject.h"
 #include "vm/TypedArrayCommon.h"
 
 namespace js {
@@ -834,18 +834,18 @@ class MUseDefIterator
     MUse *use() const {
         return *current_;
     }
     MDefinition *def() const {
         return current_->consumer()->toDefinition();
     }
 };
 
-typedef Vector<MDefinition *, 8, IonAllocPolicy> MDefinitionVector;
-typedef Vector<MInstruction *, 6, IonAllocPolicy> MInstructionVector;
+typedef Vector<MDefinition *, 8, JitAllocPolicy> MDefinitionVector;
+typedef Vector<MInstruction *, 6, JitAllocPolicy> MInstructionVector;
 
 // An instruction is an SSA name that is inserted into a basic block's IR
 // stream.
 class MInstruction
   : public MDefinition,
     public InlineListNode<MInstruction>
 {
     MResumePoint *resumePoint_;
@@ -2151,21 +2151,21 @@ class MControlInstruction : public MInst
 
 class MTableSwitch MOZ_FINAL
   : public MControlInstruction,
     public NoFloatPolicy<0>::Data
 {
     // The successors of the tableswitch
     // - First successor = the default case
     // - Successor 2 and higher = the cases sorted on case index.
-    Vector<MBasicBlock*, 0, IonAllocPolicy> successors_;
-    Vector<size_t, 0, IonAllocPolicy> cases_;
+    Vector<MBasicBlock*, 0, JitAllocPolicy> successors_;
+    Vector<size_t, 0, JitAllocPolicy> cases_;
 
     // Contains the blocks/cases that still need to get build
-    Vector<MBasicBlock*, 0, IonAllocPolicy> blocks_;
+    Vector<MBasicBlock*, 0, JitAllocPolicy> blocks_;
 
     MUse operand_;
     int32_t low_;
     int32_t high_;
 
     void initOperand(size_t index, MDefinition *operand) {
         MOZ_ASSERT(index == 0);
         operand_.init(operand, this);
@@ -6217,17 +6217,17 @@ class MLoadArrowThis
     AliasSet getAliasSet() const {
         // An arrow function's lexical |this| value is immutable.
         return AliasSet::None();
     }
 };
 
 class MPhi MOZ_FINAL : public MDefinition, public InlineListNode<MPhi>
 {
-    js::Vector<MUse, 2, IonAllocPolicy> inputs_;
+    js::Vector<MUse, 2, JitAllocPolicy> inputs_;
 
     TruncateKind truncateKind_;
     bool hasBackedgeType_;
     bool triedToSpecialize_;
     bool isIterator_;
     bool canProduceFloat32_;
     bool canConsumeFloat32_;
 
@@ -9015,33 +9015,33 @@ class MStoreFixedSlot
     }
     void setNeedsBarrier(bool needsBarrier = true) {
         needsBarrier_ = needsBarrier;
     }
 
     ALLOW_CLONE(MStoreFixedSlot)
 };
 
-typedef Vector<JSObject *, 4, IonAllocPolicy> ObjectVector;
-typedef Vector<bool, 4, IonAllocPolicy> BoolVector;
+typedef Vector<JSObject *, 4, JitAllocPolicy> ObjectVector;
+typedef Vector<bool, 4, JitAllocPolicy> BoolVector;
 
 class InlinePropertyTable : public TempObject
 {
     struct Entry : public TempObject {
         AlwaysTenured<types::TypeObject *> typeObj;
         AlwaysTenuredFunction func;
 
         Entry(types::TypeObject *typeObj, JSFunction *func)
           : typeObj(typeObj), func(func)
         { }
     };
 
     jsbytecode *pc_;
     MResumePoint *priorResumePoint_;
-    Vector<Entry *, 4, IonAllocPolicy> entries_;
+    Vector<Entry *, 4, JitAllocPolicy> entries_;
 
   public:
     InlinePropertyTable(TempAllocator &alloc, jsbytecode *pc)
       : pc_(pc), priorResumePoint_(nullptr), entries_(alloc)
     { }
 
     void setPriorResumePoint(MResumePoint *resumePoint) {
         MOZ_ASSERT(priorResumePoint_ == nullptr);
@@ -9199,17 +9199,17 @@ class MGetPropertyPolymorphic
     struct Entry {
         // The shape to guard against.
         Shape *objShape;
 
         // The property to laod.
         Shape *shape;
     };
 
-    Vector<Entry, 4, IonAllocPolicy> shapes_;
+    Vector<Entry, 4, JitAllocPolicy> shapes_;
     AlwaysTenuredPropertyName name_;
 
     MGetPropertyPolymorphic(TempAllocator &alloc, MDefinition *obj, PropertyName *name)
       : MUnaryInstruction(obj),
         shapes_(alloc),
         name_(name)
     {
         setGuard();
@@ -9270,17 +9270,17 @@ class MSetPropertyPolymorphic
     struct Entry {
         // The shape to guard against.
         Shape *objShape;
 
         // The property to laod.
         Shape *shape;
     };
 
-    Vector<Entry, 4, IonAllocPolicy> shapes_;
+    Vector<Entry, 4, JitAllocPolicy> shapes_;
     bool needsBarrier_;
 
     MSetPropertyPolymorphic(TempAllocator &alloc, MDefinition *obj, MDefinition *value)
       : MBinaryInstruction(obj, value),
         shapes_(alloc),
         needsBarrier_(false)
     {
     }
@@ -9332,17 +9332,17 @@ class MDispatchInstruction
     struct Entry {
         JSFunction *func;
         MBasicBlock *block;
 
         Entry(JSFunction *func, MBasicBlock *block)
           : func(func), block(block)
         { }
     };
-    Vector<Entry, 4, IonAllocPolicy> map_;
+    Vector<Entry, 4, JitAllocPolicy> map_;
 
     // An optional fallback path that uses MCall.
     MBasicBlock *fallback_;
     MUse operand_;
 
     void initOperand(size_t index, MDefinition *operand) {
         MOZ_ASSERT(index == 0);
         operand_.init(operand, this);
@@ -9598,17 +9598,17 @@ class MGuardShape
     }
 };
 
 // Bail if the object's shape is not one of the shapes in shapes_.
 class MGuardShapePolymorphic
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
-    Vector<Shape *, 4, IonAllocPolicy> shapes_;
+    Vector<Shape *, 4, JitAllocPolicy> shapes_;
 
     MGuardShapePolymorphic(TempAllocator &alloc, MDefinition *obj)
       : MUnaryInstruction(obj),
         shapes_(alloc)
     {
         setGuard();
         setMovable();
         setResultType(MIRType_Object);
--- a/js/src/jit/MIRGenerator.h
+++ b/js/src/jit/MIRGenerator.h
@@ -13,17 +13,17 @@
 #include "mozilla/Atomics.h"
 
 #include <stdarg.h>
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/CompileInfo.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/JitCompartment.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/RegisterSets.h"
 
 namespace js {
 namespace jit {
@@ -45,17 +45,17 @@ class MIRGenerator
     }
     MIRGraph &graph() {
         return *graph_;
     }
     bool ensureBallast() {
         return alloc().ensureBallast();
     }
     const JitRuntime *jitRuntime() const {
-        return GetIonContext()->runtime->jitRuntime();
+        return GetJitContext()->runtime->jitRuntime();
     }
     CompileInfo &info() {
         return *info_;
     }
     const OptimizationInfo &optimizationInfo() const {
         return *optimizationInfo_;
     }
 
@@ -72,17 +72,17 @@ class MIRGenerator
     bool abortFmt(const char *message, va_list ap);
 
     bool errored() const {
         return error_;
     }
 
     bool instrumentedProfiling() {
         if (!instrumentedProfilingIsCached_) {
-            instrumentedProfiling_ = GetIonContext()->runtime->spsProfiler().enabled();
+            instrumentedProfiling_ = GetJitContext()->runtime->spsProfiler().enabled();
             instrumentedProfilingIsCached_ = true;
         }
         return instrumentedProfiling_;
     }
 
     bool isNativeToBytecodeMapEnabled() {
         if (compilingAsmJS())
             return false;
@@ -151,17 +151,17 @@ class MIRGenerator
     uint32_t minAsmJSHeapLength() const {
         return minAsmJSHeapLength_;
     }
 
     bool modifiesFrameArguments() const {
         return modifiesFrameArguments_;
     }
 
-    typedef Vector<types::TypeObject *, 0, IonAllocPolicy> TypeObjectVector;
+    typedef Vector<types::TypeObject *, 0, JitAllocPolicy> TypeObjectVector;
 
     // When abortReason() == AbortReason_NewScriptProperties, all types which
     // the new script properties analysis hasn't been performed on yet.
     const TypeObjectVector &abortedNewScriptPropertiesTypes() const {
         return abortedNewScriptPropertiesTypes_;
     }
 
   public:
--- a/js/src/jit/MIRGraph.h
+++ b/js/src/jit/MIRGraph.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_MIRGraph_h
 #define jit_MIRGraph_h
 
 // This file declares the data structures used to build a control-flow graph
 // containing MIR.
 
 #include "jit/FixedList.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/MIR.h"
 
 namespace js {
 namespace jit {
 
 class BytecodeAnalysis;
 class MBasicBlock;
 class MIRGraph;
@@ -618,17 +618,17 @@ class MBasicBlock : public TempObject, p
     InlineScriptTree *trackedTree() const {
         return trackedSite_ ? trackedSite_->tree() : nullptr;
     }
 
   private:
     MIRGraph &graph_;
     CompileInfo &info_; // Each block originates from a particular script.
     InlineList<MInstruction> instructions_;
-    Vector<MBasicBlock *, 1, IonAllocPolicy> predecessors_;
+    Vector<MBasicBlock *, 1, JitAllocPolicy> predecessors_;
     InlineList<MPhi> phis_;
     FixedList<MDefinition *> slots_;
     uint32_t stackPosition_;
     uint32_t id_;
     uint32_t domIndex_; // Index in the dominator tree.
     uint32_t numDominated_;
     jsbytecode *pc_;
     LBlock *lir_;
@@ -650,17 +650,17 @@ class MBasicBlock : public TempObject, p
     MBasicBlock *successorWithPhis_;
     uint32_t positionInPhiSuccessor_;
     uint32_t loopDepth_;
     Kind kind_ : 8;
 
     // Utility mark for traversal algorithms.
     bool mark_;
 
-    Vector<MBasicBlock *, 1, IonAllocPolicy> immediatelyDominated_;
+    Vector<MBasicBlock *, 1, JitAllocPolicy> immediatelyDominated_;
     MBasicBlock *immediateDominator_;
 
     const BytecodeSite *trackedSite_;
 
 #if defined(JS_ION_PERF) || defined(DEBUG)
     unsigned lineno_;
     unsigned columnIndex_;
 
@@ -671,17 +671,17 @@ class MBasicBlock : public TempObject, p
     unsigned columnIndex() const { return columnIndex_; }
 #endif
 };
 
 typedef InlineListIterator<MBasicBlock> MBasicBlockIterator;
 typedef InlineListIterator<MBasicBlock> ReversePostorderIterator;
 typedef InlineListReverseIterator<MBasicBlock> PostorderIterator;
 
-typedef Vector<MBasicBlock *, 1, IonAllocPolicy> MIRGraphReturns;
+typedef Vector<MBasicBlock *, 1, JitAllocPolicy> MIRGraphReturns;
 
 class MIRGraph
 {
     InlineList<MBasicBlock> blocks_;
     TempAllocator *alloc_;
     MIRGraphReturns *returnAccumulator_;
     uint32_t blockIdGen_;
     uint32_t idGen_;
rename from js/src/jit/IonMacroAssembler.cpp
rename to js/src/jit/MacroAssembler.cpp
--- a/js/src/jit/IonMacroAssembler.cpp
+++ b/js/src/jit/MacroAssembler.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 #include "jsinfer.h"
 #include "jsprf.h"
 
 #include "builtin/TypedObject.h"
 #include "gc/GCTrace.h"
 #include "jit/AtomicOp.h"
 #include "jit/Bailouts.h"
@@ -611,23 +611,23 @@ MacroAssembler::checkAllocatorState(Labe
 {
     // Don't execute the inline path if we are tracing allocations.
     if (js::gc::TraceEnabled())
         jump(fail);
 
 # ifdef JS_GC_ZEAL
     // Don't execute the inline path if gc zeal or tracing are active.
     branch32(Assembler::NotEqual,
-             AbsoluteAddress(GetIonContext()->runtime->addressOfGCZeal()), Imm32(0),
+             AbsoluteAddress(GetJitContext()->runtime->addressOfGCZeal()), Imm32(0),
              fail);
 # endif
 
     // Don't execute the inline path if the compartment has an object metadata callback,
     // as the metadata to use for the object may vary between executions of the op.
-    if (GetIonContext()->compartment->hasObjectMetadataCallback())
+    if (GetJitContext()->compartment->hasObjectMetadataCallback())
         jump(fail);
 }
 
 // Inline version of ShouldNurseryAllocate.
 bool
 MacroAssembler::shouldNurseryAllocate(gc::AllocKind allocKind, gc::InitialHeap initialHeap)
 {
 #ifdef JSGC_GENERATIONAL
@@ -656,17 +656,17 @@ MacroAssembler::nurseryAllocate(Register
     // bail to do the nursery allocation in the interpreter.
     if (nDynamicSlots >= Nursery::MaxNurserySlots) {
         jump(fail);
         return;
     }
 
     // No explicit check for nursery.isEnabled() is needed, as the comparison
     // with the nursery's end will always fail in such cases.
-    const Nursery &nursery = GetIonContext()->runtime->gcNursery();
+    const Nursery &nursery = GetJitContext()->runtime->gcNursery();
     Register temp = slots;
     int thingSize = int(gc::Arena::thingSize(allocKind));
     int totalSize = thingSize + nDynamicSlots * sizeof(HeapSlot);
     loadPtr(AbsoluteAddress(nursery.addressOfPosition()), result);
     computeEffectiveAddress(Address(result, totalSize), temp);
     branchPtr(Assembler::Below, AbsoluteAddress(nursery.addressOfCurrentEnd()), temp, fail);
     storePtr(temp, AbsoluteAddress(nursery.addressOfPosition()));
 
@@ -674,17 +674,17 @@ MacroAssembler::nurseryAllocate(Register
         computeEffectiveAddress(Address(result, thingSize), slots);
 #endif // JSGC_GENERATIONAL
 }
 
 // Inlined version of FreeList::allocate.
 void
 MacroAssembler::freeListAllocate(Register result, Register temp, gc::AllocKind allocKind, Label *fail)
 {
-    CompileZone *zone = GetIonContext()->compartment->zone();
+    CompileZone *zone = GetJitContext()->compartment->zone();
     int thingSize = int(gc::Arena::thingSize(allocKind));
 
     Label fallback;
     Label success;
 
     // Load FreeList::head::first of |zone|'s freeLists for |allocKind|. If
     // there is no room remaining in the span, fall back to get the next one.
     loadPtr(AbsoluteAddress(zone->addressOfFreeListFirst(allocKind)), result);
@@ -714,33 +714,33 @@ MacroAssembler::callMallocStub(size_t nb
     const Register regNBytes = CallTempReg0;
 
     MOZ_ASSERT(nbytes > 0);
     MOZ_ASSERT(nbytes <= INT32_MAX);
 
     if (regNBytes != result)
         push(regNBytes);
     move32(Imm32(nbytes), regNBytes);
-    call(GetIonContext()->runtime->jitRuntime()->mallocStub());
+    call(GetJitContext()->runtime->jitRuntime()->mallocStub());
     if (regNBytes != result) {
         movePtr(regNBytes, result);
         pop(regNBytes);
     }
     branchTest32(Assembler::Zero, result, result, fail);
 }
 
 void
 MacroAssembler::callFreeStub(Register slots)
 {
     // This register must match the one in JitRuntime::generateFreeStub.
     const Register regSlots = CallTempReg0;
 
     push(regSlots);
     movePtr(slots, regSlots);
-    call(GetIonContext()->runtime->jitRuntime()->freeStub());
+    call(GetJitContext()->runtime->jitRuntime()->freeStub());
     pop(regSlots);
 }
 
 // Inlined equivalent of gc::AllocateObject, without failure case handling.
 void
 MacroAssembler::allocateObject(Register result, Register slots, gc::AllocKind allocKind,
                                uint32_t nDynamicSlots, gc::InitialHeap initialHeap, Label *fail)
 {
@@ -1233,26 +1233,26 @@ MacroAssembler::loadStringChar(Register 
     load8ZeroExtend(BaseIndex(output, index, TimesOne), output);
 
     bind(&done);
 }
 
 void
 MacroAssembler::checkInterruptFlagPar(Register tempReg, Label *fail)
 {
-    movePtr(ImmPtr(GetIonContext()->runtime->addressOfInterruptParUint32()), tempReg);
+    movePtr(ImmPtr(GetJitContext()->runtime->addressOfInterruptParUint32()), tempReg);
     branch32(Assembler::NonZero, Address(tempReg, 0), Imm32(0), fail);
 }
 
 // Save an exit frame (which must be aligned to the stack pointer) to
 // PerThreadData::jitTop of the main thread.
 void
 MacroAssembler::linkExitFrame()
 {
-    AbsoluteAddress jitTop(GetIonContext()->runtime->addressOfJitTop());
+    AbsoluteAddress jitTop(GetJitContext()->runtime->addressOfJitTop());
     storePtr(StackPointer, jitTop);
 }
 
 // Save an exit frame to the thread data of the current thread, given a
 // register that holds a PerThreadData *.
 void
 MacroAssembler::linkParallelExitFrame(Register pt)
 {
@@ -1326,17 +1326,17 @@ MacroAssembler::generateBailoutTail(Regi
 
         // Enter exit frame for the FinishBailoutToBaseline call.
         loadPtr(Address(bailoutInfo, offsetof(BaselineBailoutInfo, resumeFramePtr)), temp);
         load32(Address(temp, BaselineFrame::reverseOffsetOfFrameSize()), temp);
         makeFrameDescriptor(temp, JitFrame_BaselineJS);
         push(temp);
         push(Address(bailoutInfo, offsetof(BaselineBailoutInfo, resumeAddr)));
         // No GC things to mark on the stack, push a bare token.
-        enterFakeExitFrame(IonExitFrameLayout::BareToken());
+        enterFakeExitFrame(ExitFrameLayout::BareToken());
 
         // If monitorStub is non-null, handle resumeAddr appropriately.
         Label noMonitor;
         Label done;
         branchPtr(Assembler::Equal,
                   Address(bailoutInfo, offsetof(BaselineBailoutInfo, monitorStub)),
                   ImmPtr(nullptr),
                   &noMonitor);
@@ -1365,17 +1365,17 @@ MacroAssembler::generateBailoutTail(Regi
             enterMonRegs.takeUnchecked(BaselineTailCallReg);
 
             pop(BaselineStubReg);
             pop(BaselineTailCallReg);
             pop(BaselineFrameReg);
             popValue(R0);
 
             // Discard exit frame.
-            addPtr(Imm32(IonExitFrameLayout::SizeWithFooter()), StackPointer);
+            addPtr(Imm32(ExitFrameLayout::SizeWithFooter()), StackPointer);
 
 #if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
             push(BaselineTailCallReg);
 #endif
             jump(Address(BaselineStubReg, ICStub::offsetOfStubCode()));
         }
 
         //
@@ -1403,17 +1403,17 @@ MacroAssembler::generateBailoutTail(Regi
             Register jitcodeReg = enterRegs.takeAny();
 
             pop(jitcodeReg);
             pop(BaselineFrameReg);
             popValue(R1);
             popValue(R0);
 
             // Discard exit frame.
-            addPtr(Imm32(IonExitFrameLayout::SizeWithFooter()), StackPointer);
+            addPtr(Imm32(ExitFrameLayout::SizeWithFooter()), StackPointer);
 
             jump(jitcodeReg);
         }
     }
 }
 
 void
 MacroAssembler::loadBaselineOrIonRaw(Register script, Register dest, ExecutionMode mode,
rename from js/src/jit/IonMacroAssembler.h
rename to js/src/jit/MacroAssembler.h
--- a/js/src/jit/IonMacroAssembler.h
+++ b/js/src/jit/MacroAssembler.h
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef jit_IonMacroAssembler_h
-#define jit_IonMacroAssembler_h
+#ifndef jit_MacroAssembler_h
+#define jit_MacroAssembler_h
 
 #include "jscompartment.h"
 
 #if defined(JS_CODEGEN_X86)
 # include "jit/x86/MacroAssembler-x86.h"
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/MacroAssembler-x64.h"
 #elif defined(JS_CODEGEN_ARM)
@@ -177,18 +177,18 @@ class MacroAssembler : public MacroAssem
 
         void emit(MacroAssembler &masm) {
             MOZ_ASSERT(isInitialized());
             masm.branchPtr(cond(), reg(), ptr_, jump());
         }
     };
 
     mozilla::Maybe<AutoRooter> autoRooter_;
-    mozilla::Maybe<IonContext> ionContext_;
-    mozilla::Maybe<AutoIonContextAlloc> alloc_;
+    mozilla::Maybe<JitContext> jitContext_;
+    mozilla::Maybe<AutoJitContextAlloc> alloc_;
 
     // SPS instrumentation, only used for Ion caches.
     mozilla::Maybe<IonInstrumentation> spsInstrumentation_;
     jsbytecode *spsPc_;
 
   private:
     // This field is used to manage profiling instrumentation output. If
     // provided and enabled, then instrumentation will be emitted around call
@@ -203,61 +203,61 @@ class MacroAssembler : public MacroAssem
 
   public:
     // If instrumentation should be emitted, then the sps parameter should be
     // provided, but otherwise it can be safely omitted to prevent all
     // instrumentation from being emitted.
     MacroAssembler()
       : sps_(nullptr)
     {
-        IonContext *icx = GetIonContext();
-        JSContext *cx = icx->cx;
+        JitContext *jcx = GetJitContext();
+        JSContext *cx = jcx->cx;
         if (cx)
             constructRoot(cx);
 
-        if (!icx->temp) {
+        if (!jcx->temp) {
             MOZ_ASSERT(cx);
             alloc_.emplace(cx);
         }
 
-        moveResolver_.setAllocator(*icx->temp);
+        moveResolver_.setAllocator(*jcx->temp);
 #ifdef JS_CODEGEN_ARM
         initWithAllocator();
-        m_buffer.id = icx->getNextAssemblerId();
+        m_buffer.id = jcx->getNextAssemblerId();
 #endif
     }
 
-    // This constructor should only be used when there is no IonContext active
+    // This constructor should only be used when there is no JitContext active
     // (for example, Trampoline-$(ARCH).cpp and IonCaches.cpp).
     explicit MacroAssembler(JSContext *cx, IonScript *ion = nullptr,
                             JSScript *script = nullptr, jsbytecode *pc = nullptr)
       : sps_(nullptr)
     {
         constructRoot(cx);
-        ionContext_.emplace(cx, (js::jit::TempAllocator *)nullptr);
+        jitContext_.emplace(cx, (js::jit::TempAllocator *)nullptr);
         alloc_.emplace(cx);
-        moveResolver_.setAllocator(*ionContext_->temp);
+        moveResolver_.setAllocator(*jitContext_->temp);
 #ifdef JS_CODEGEN_ARM
         initWithAllocator();
-        m_buffer.id = GetIonContext()->getNextAssemblerId();
+        m_buffer.id = GetJitContext()->getNextAssemblerId();
 #endif
         if (ion) {
             setFramePushed(ion->frameSize());
             if (pc && cx->runtime()->spsProfiler.enabled()) {
                 // We have to update the SPS pc when this IC stub calls into
                 // the VM.
                 spsPc_ = pc;
                 spsInstrumentation_.emplace(&cx->runtime()->spsProfiler, &spsPc_);
                 sps_ = spsInstrumentation_.ptr();
                 sps_->setPushed(script);
             }
         }
     }
 
-    // asm.js compilation handles its own IonContext-pushing
+    // asm.js compilation handles its own JitContext-pushing
     struct AsmJSToken {};
     explicit MacroAssembler(AsmJSToken)
       : sps_(nullptr)
     {
 #ifdef JS_CODEGEN_ARM
         initWithAllocator();
         m_buffer.id = 0;
 #endif
@@ -393,20 +393,20 @@ class MacroAssembler : public MacroAssem
         branchTest32(Assembler::Zero, flags, Imm32(JSString::TYPE_FLAGS_MASK), label);
     }
 
     void loadSliceBounds(Register worker, Register dest) {
         loadPtr(Address(worker, ThreadPoolWorker::offsetOfSliceBounds()), dest);
     }
 
     void loadJSContext(Register dest) {
-        loadPtr(AbsoluteAddress(GetIonContext()->runtime->addressOfJSContext()), dest);
+        loadPtr(AbsoluteAddress(GetJitContext()->runtime->addressOfJSContext()), dest);
     }
     void loadJitActivation(Register dest) {
-        loadPtr(AbsoluteAddress(GetIonContext()->runtime->addressOfActivation()), dest);
+        loadPtr(AbsoluteAddress(GetJitContext()->runtime->addressOfActivation()), dest);
     }
 
     template<typename T>
     void loadTypedOrValue(const T &src, TypedOrValueRegister dest) {
         if (dest.hasValue())
             loadValue(src, dest.valueReg());
         else
             loadUnboxedValue(src, dest.type(), dest.typedReg());
@@ -652,32 +652,32 @@ class MacroAssembler : public MacroAssem
         if (key.isRegister())
             branch32(cond, length, key.reg(), label);
         else
             branch32(cond, length, Imm32(key.constant()), label);
     }
 
     void branchTestNeedsIncrementalBarrier(Condition cond, Label *label) {
         MOZ_ASSERT(cond == Zero || cond == NonZero);
-        CompileZone *zone = GetIonContext()->compartment->zone();
+        CompileZone *zone = GetJitContext()->compartment->zone();
         AbsoluteAddress needsBarrierAddr(zone->addressOfNeedsIncrementalBarrier());
         branchTest32(cond, needsBarrierAddr, Imm32(0x1), label);
     }
 
     template <typename T>
     void callPreBarrier(const T &address, MIRType type) {
         Label done;
 
         if (type == MIRType_Value)
             branchTestGCThing(Assembler::NotEqual, address, &done);
 
         Push(PreBarrierReg);
         computeEffectiveAddress(address, PreBarrierReg);
 
-        const JitRuntime *rt = GetIonContext()->runtime->jitRuntime();
+        const JitRuntime *rt = GetJitContext()->runtime->jitRuntime();
         JitCode *preBarrier = rt->preBarrier(type);
 
         call(preBarrier);
         Pop(PreBarrierReg);
 
         bind(&done);
     }
 
@@ -870,27 +870,27 @@ class MacroAssembler : public MacroAssem
         linkExitFrame();
         // Push the ioncode. (Bailout or VM wrapper)
         exitCodePatch_ = PushWithPatch(ImmWord(-1));
         // Push VMFunction pointer, to mark arguments.
         Push(ImmPtr(f));
     }
 
     // The JitCode * argument here is one of the tokens defined in the various
-    // exit frame layout classes, e.g. IonNativeExitFrameLayout::Token().
+    // exit frame layout classes, e.g. NativeExitFrameLayout::Token().
     void enterFakeExitFrame(JitCode *codeVal) {
         linkExitFrame();
         Push(ImmPtr(codeVal));
         Push(ImmPtr(nullptr));
     }
 
     void loadThreadPool(Register pool) {
         // JitRuntimes are tied to JSRuntimes and there is one ThreadPool per
         // JSRuntime, so we can hardcode the ThreadPool address here.
-        movePtr(ImmPtr(GetIonContext()->runtime->addressOfThreadPool()), pool);
+        movePtr(ImmPtr(GetJitContext()->runtime->addressOfThreadPool()), pool);
     }
 
     void loadForkJoinContext(Register cx, Register scratch);
     void loadContext(Register cxReg, Register scratch, ExecutionMode executionMode);
 
     void enterParallelExitFrameAndLoadContext(const VMFunction *f, Register cx,
                                               Register scratch);
 
@@ -898,17 +898,17 @@ class MacroAssembler : public MacroAssem
                                       ExecutionMode executionMode);
 
     void enterFakeParallelExitFrame(Register cx, Register scratch, JitCode *codeVal);
 
     void enterFakeExitFrame(Register cxReg, Register scratch, ExecutionMode executionMode,
                             JitCode *codeVal);
 
     void leaveExitFrame() {
-        freeStack(IonExitFooterFrame::Size());
+        freeStack(ExitFooterFrame::Size());
     }
 
     bool hasEnteredExitFrame() const {
         return exitCodePatch_.offset() != 0;
     }
 
     void link(JitCode *code) {
         MOZ_ASSERT(!oom());
@@ -942,19 +942,19 @@ class MacroAssembler : public MacroAssem
     template <typename T>
     void callWithABI(const T &fun, MoveOp::Type result = MoveOp::GENERAL) {
         leaveSPSFrame();
         callWithABINoProfiling(fun, result);
         reenterSPSFrame();
     }
 
     // see above comment for what is returned
-    uint32_t callIon(Register callee) {
+    uint32_t callJit(Register callee) {
         leaveSPSFrame();
-        MacroAssemblerSpecific::callIon(callee);
+        MacroAssemblerSpecific::callJit(callee);
         uint32_t ret = currentOffset();
         reenterSPSFrame();
         return ret;
     }
 
     // see above comment for what is returned
     uint32_t callWithExitFrame(Label *target) {
         leaveSPSFrame();
@@ -1549,9 +1549,9 @@ StackDecrementForCall(uint32_t alignment
 {
     return bytesToPush +
            ComputeByteAlignment(bytesAlreadyPushed + bytesToPush, alignment);
 }
 
 } // namespace jit
 } // namespace js
 
-#endif /* jit_IonMacroAssembler_h */
+#endif /* jit_MacroAssembler_h */
--- a/js/src/jit/MoveResolver.h
+++ b/js/src/jit/MoveResolver.h
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_MoveResolver_h
 #define jit_MoveResolver_h
 
 #include "jit/InlineList.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/Registers.h"
 
 namespace js {
 namespace jit {
 
 // This is similar to Operand, but carries more information. We're also not
 // guaranteed that Operand looks like this on all ISAs.
 class MoveOperand
--- a/js/src/jit/ParallelFunctions.cpp
+++ b/js/src/jit/ParallelFunctions.cpp
@@ -534,17 +534,17 @@ void
 jit::BailoutPar(BailoutStack *sp, uint8_t **entryFramePointer)
 {
     parallel::Spew(parallel::SpewBailouts, "Bailing");
 
     ForkJoinContext *cx = ForkJoinContext::current();
 
     // We don't have an exit frame.
     MOZ_ASSERT(IsInRange(FAKE_JIT_TOP_FOR_BAILOUT, 0, 0x1000) &&
-               IsInRange(FAKE_JIT_TOP_FOR_BAILOUT + sizeof(IonCommonFrameLayout), 0, 0x1000),
+               IsInRange(FAKE_JIT_TOP_FOR_BAILOUT + sizeof(CommonFrameLayout), 0, 0x1000),
                "Fake jitTop pointer should be within the first page.");
     cx->perThreadData->jitTop = FAKE_JIT_TOP_FOR_BAILOUT;
 
     JitActivationIterator jitActivations(cx->perThreadData);
     BailoutFrameInfo bailoutData(jitActivations, sp);
     JitFrameIterator frameIter(jitActivations);
     SnapshotIterator snapIter(frameIter);
 
--- a/js/src/jit/ParallelSafetyAnalysis.h
+++ b/js/src/jit/ParallelSafetyAnalysis.h
@@ -37,15 +37,15 @@ class ParallelSafetyAnalysis
 };
 
 // Code to collect list of possible call targets by scraping through
 // TI and baseline data. Used to permit speculative transitive
 // compilation in vm/ForkJoin.
 //
 // This code may clone scripts and thus may invoke the GC.  Hence only
 // run from the link phase, which executes on the main thread.
-typedef Vector<JSScript *, 4, IonAllocPolicy> CallTargetVector;
+typedef Vector<JSScript *, 4, JitAllocPolicy> CallTargetVector;
 bool AddPossibleCallees(JSContext *cx, MIRGraph &graph, CallTargetVector &targets);
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_ParallelSafetyAnalysis_h */
--- a/js/src/jit/PerfSpewer.h
+++ b/js/src/jit/PerfSpewer.h
@@ -4,17 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_PerfSpewer_h
 #define jit_PerfSpewer_h
 
 #ifdef JS_ION_PERF
 # include <stdio.h>
-# include "jit/IonMacroAssembler.h"
+# include "jit/MacroAssembler.h"
 #endif
 
 namespace js {
 namespace jit {
 
 class MBasicBlock;
 class MacroAssembler;
 
--- a/js/src/jit/RangeAnalysis.cpp
+++ b/js/src/jit/RangeAnalysis.cpp
@@ -318,17 +318,17 @@ SymbolicBound::print(Sprinter &sp) const
     if (loop)
         sp.printf("[loop] ");
     sum.print(sp);
 }
 
 void
 SymbolicBound::dump() const
 {
-    Sprinter sp(GetIonContext()->cx);
+    Sprinter sp(GetJitContext()->cx);
     sp.init();
     print(sp);
     fprintf(stderr, "%s\n", sp.string());
 }
 
 // Test whether the given range's exponent tells us anything that its lower
 // and upper bound values don't.
 static bool
@@ -429,17 +429,17 @@ Range::print(Sprinter &sp) const
     }
     if (max_exponent_ < IncludesInfinity && IsExponentInteresting(this))
         sp.printf(" (< pow(2, %d+1))", max_exponent_);
 }
 
 void
 Range::dump(FILE *fp) const
 {
-    Sprinter sp(GetIonContext()->cx);
+    Sprinter sp(GetJitContext()->cx);
     sp.init();
     print(sp);
     fprintf(fp, "%s\n", sp.string());
 }
 
 void
 Range::dump() const
 {
@@ -1817,34 +1817,34 @@ RangeAnalysis::analyzeLoop(MBasicBlock *
         return true;
     }
 
     if (!loopIterationBounds.append(iterationBound))
         return false;
 
 #ifdef DEBUG
     if (JitSpewEnabled(JitSpew_Range)) {
-        Sprinter sp(GetIonContext()->cx);
+        Sprinter sp(GetJitContext()->cx);
         sp.init();
         iterationBound->boundSum.print(sp);
         JitSpew(JitSpew_Range, "computed symbolic bound on backedges: %s",
                 sp.string());
     }
 #endif
 
     // Try to compute symbolic bounds for the phi nodes at the head of this
     // loop, expressed in terms of the iteration bound just computed.
 
     for (MPhiIterator iter(header->phisBegin()); iter != header->phisEnd(); iter++)
         analyzeLoopPhi(header, iterationBound, *iter);
 
     if (!mir->compilingAsmJS()) {
         // Try to hoist any bounds checks from the loop using symbolic bounds.
 
-        Vector<MBoundsCheck *, 0, IonAllocPolicy> hoistedChecks(alloc());
+        Vector<MBoundsCheck *, 0, JitAllocPolicy> hoistedChecks(alloc());
 
         for (ReversePostorderIterator iter(graph_.rpoBegin(header)); iter != graph_.rpoEnd(); iter++) {
             MBasicBlock *block = *iter;
             if (!block->isMarked())
                 continue;
 
             for (MDefinitionIterator iter(block); iter; iter++) {
                 MDefinition *def = *iter;
--- a/js/src/jit/Recover.cpp
+++ b/js/src/jit/Recover.cpp
@@ -64,25 +64,25 @@ MResumePoint::writeRecoverData(CompactBu
     MBasicBlock *bb = block();
     JSFunction *fun = bb->info().funMaybeLazy();
     JSScript *script = bb->info().script();
     uint32_t exprStack = stackDepth() - bb->info().ninvoke();
 
 #ifdef DEBUG
     // Ensure that all snapshot which are encoded can safely be used for
     // bailouts.
-    if (GetIonContext()->cx) {
+    if (GetJitContext()->cx) {
         uint32_t stackDepth;
         bool reachablePC;
         jsbytecode *bailPC = pc();
 
         if (mode() == MResumePoint::ResumeAfter)
             bailPC = GetNextPc(pc());
 
-        if (!ReconstructStackDepth(GetIonContext()->cx, script,
+        if (!ReconstructStackDepth(GetJitContext()->cx, script,
                                    bailPC, &stackDepth, &reachablePC))
         {
             return false;
         }
 
         if (reachablePC) {
             if (JSOp(*bailPC) == JSOP_FUNCALL) {
                 // For fun.call(this, ...); the reconstructStackDepth will
--- a/js/src/jit/RegisterSets.h
+++ b/js/src/jit/RegisterSets.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_RegisterSets_h
 #define jit_RegisterSets_h
 
 #include "mozilla/Alignment.h"
 #include "mozilla/MathAlgorithms.h"
 
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/Registers.h"
 
 namespace js {
 namespace jit {
 
 struct AnyRegister {
     typedef uint32_t Code;
 
--- a/js/src/jit/RematerializedFrame.cpp
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -1,21 +1,21 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/RematerializedFrame.h"
-#include "jit/IonFrames.h"
 
+#include "jit/JitFrames.h"
 #include "vm/ArgumentsObject.h"
 
 #include "jsscriptinlines.h"
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 
 using namespace js;
 using namespace jit;
 
 struct CopyValueToRematerializedFrame
 {
     Value *slots;
 
--- a/js/src/jit/RematerializedFrame.h
+++ b/js/src/jit/RematerializedFrame.h
@@ -4,18 +4,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_RematerializedFrame_h
 #define jit_RematerializedFrame_h
 
 #include "jsfun.h"
 
-#include "jit/IonFrames.h"
 #include "jit/JitFrameIterator.h"
+#include "jit/JitFrames.h"
 
 #include "vm/Stack.h"
 
 namespace js {
 namespace jit {
 
 //
 // An optimized frame that has been rematerialized with values read out of
@@ -83,17 +83,17 @@ class RematerializedFrame
         MOZ_ASSERT(!script()->isDebuggee());
         isDebuggee_ = false;
     }
 
     uint8_t *top() const {
         return top_;
     }
     JSScript *outerScript() const {
-        IonJSFrameLayout *jsFrame = (IonJSFrameLayout *)top_;
+        JitFrameLayout *jsFrame = (JitFrameLayout *)top_;
         return ScriptFromCalleeToken(jsFrame->calleeToken());
     }
     jsbytecode *pc() const {
         return pc_;
     }
     size_t frameNo() const {
         return frameNo_;
     }
--- a/js/src/jit/TypePolicy.h
+++ b/js/src/jit/TypePolicy.h
@@ -2,18 +2,18 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_TypePolicy_h
 #define jit_TypePolicy_h
 
-#include "jit/IonAllocPolicy.h"
 #include "jit/IonTypes.h"
+#include "jit/JitAllocPolicy.h"
 
 namespace js {
 namespace jit {
 
 class MInstruction;
 class MDefinition;
 
 // A type policy directs the type analysis phases, which insert conversion,
--- a/js/src/jit/TypedObjectPrediction.h
+++ b/js/src/jit/TypedObjectPrediction.h
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_TypedObjectPrediction_h
 #define jit_TypedObjectPrediction_h
 
 #include "builtin/TypedObject.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 
 namespace js {
 namespace jit {
 
 // A TypedObjectPrediction summarizes what we know about the type of a
 // typed object at a given point (if anything). The prediction will
 // begin as precise as possible and degrade to less precise as more
 // typed object types are merged using |addDescr()|.
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -5,28 +5,28 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/VMFunctions.h"
 
 #include "builtin/TypedObject.h"
 #include "frontend/BytecodeCompiler.h"
 #include "jit/arm/Simulator-arm.h"
 #include "jit/BaselineIC.h"
-#include "jit/IonFrames.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/mips/Simulator-mips.h"
 #include "vm/ArrayObject.h"
 #include "vm/Debugger.h"
 #include "vm/Interpreter.h"
 #include "vm/TraceLogging.h"
 
 #include "jsinferinlines.h"
 
 #include "jit/BaselineFrame-inl.h"
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Debugger-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/StringObject-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
@@ -35,17 +35,17 @@ namespace jit {
 
 // Don't explicitly initialize, it's not guaranteed that this initializer will
 // run before the constructors for static VMFunctions.
 /* static */ VMFunction *VMFunction::functions;
 
 AutoDetectInvalidation::AutoDetectInvalidation(JSContext *cx, MutableHandleValue rval,
                                                IonScript *ionScript)
   : cx_(cx),
-    ionScript_(ionScript ? ionScript : GetTopIonJSScript(cx)->ionScript()),
+    ionScript_(ionScript ? ionScript : GetTopJitJSScript(cx)->ionScript()),
     rval_(rval),
     disabled_(false)
 { }
 
 void
 VMFunction::addToFunctions()
 {
     static bool initialized = false;
@@ -817,17 +817,17 @@ DebugEpilogue(JSContext *cx, BaselineFra
         // want to double-pop SPS frames.
         frame->unsetPushedSPSFrame();
     }
 
     if (!ok) {
         // Pop this frame by updating jitTop, so that the exception handling
         // code will start at the previous frame.
 
-        IonJSFrameLayout *prefix = frame->framePrefix();
+        JitFrameLayout *prefix = frame->framePrefix();
         EnsureExitFrame(prefix);
         cx->mainThread().jitTop = (uint8_t *)prefix;
     }
 
     return ok;
 }
 
 JSObject *
--- a/js/src/jit/VMFunctions.h
+++ b/js/src/jit/VMFunctions.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_VMFunctions_h
 #define jit_VMFunctions_h
 
 #include "jspubtd.h"
 
 #include "jit/CompileInfo.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 
 namespace js {
 
 class DeclEnvObject;
 class ForkJoinContext;
 class StaticWithObject;
 class InlineTypedObject;
 
--- a/js/src/jit/ValueNumbering.h
+++ b/js/src/jit/ValueNumbering.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_ValueNumbering_h
 #define jit_ValueNumbering_h
 
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "js/HashTable.h"
 
 namespace js {
 namespace jit {
 
 class MDefinition;
 class MBasicBlock;
 class MIRGraph;
@@ -31,17 +31,17 @@ class ValueNumberer
         {
             typedef const MDefinition *Lookup;
             typedef MDefinition *Key;
             static HashNumber hash(Lookup ins);
             static bool match(Key k, Lookup l);
             static void rekey(Key &k, Key newKey);
         };
 
-        typedef HashSet<MDefinition *, ValueHasher, IonAllocPolicy> ValueSet;
+        typedef HashSet<MDefinition *, ValueHasher, JitAllocPolicy> ValueSet;
 
         ValueSet set_;        // Set of visible values
 
       public:
         explicit VisibleValues(TempAllocator &alloc);
         bool init();
 
         typedef ValueSet::Ptr Ptr;
@@ -53,18 +53,18 @@ class ValueNumberer
         void overwrite(AddPtr p, MDefinition *def);
         void forget(const MDefinition *def);
         void clear();
 #ifdef DEBUG
         bool has(const MDefinition *def) const;
 #endif
     };
 
-    typedef Vector<MBasicBlock *, 4, IonAllocPolicy> BlockWorklist;
-    typedef Vector<MDefinition *, 4, IonAllocPolicy> DefWorklist;
+    typedef Vector<MBasicBlock *, 4, JitAllocPolicy> BlockWorklist;
+    typedef Vector<MDefinition *, 4, JitAllocPolicy> DefWorklist;
 
     MIRGenerator *const mir_;
     MIRGraph &graph_;
     VisibleValues values_;            // Numbered values
     DefWorklist deadDefs_;            // Worklist for deleting values
     BlockWorklist remainingBlocks_;   // Blocks remaining with fewer preds
     MDefinition *nextDef_;            // The next definition; don't discard
     size_t totalNumVisited_;          // The number of blocks visited
--- a/js/src/jit/arm/Assembler-arm.h
+++ b/js/src/jit/arm/Assembler-arm.h
@@ -1209,18 +1209,18 @@ class Assembler : public AssemblerShared
     Assembler()
       : m_buffer(1, 1, 8, GetPoolMaxOffset(), 8, 0xe320f000, 0xeaffffff, GetNopFill()),
         isFinished(false),
         dtmActive(false),
         dtmCond(Always)
     {
     }
 
-    // We need to wait until an AutoIonContextAlloc is created by the
-    // IonMacroAssembler, before allocating any space.
+    // We need to wait until an AutoJitContextAlloc is created by the
+    // MacroAssembler, before allocating any space.
     void initWithAllocator() {
         m_buffer.initWithAllocator();
     }
 
     static Condition InvertCondition(Condition cond);
 
     // MacroAssemblers hold onto gcthings, so they are traced by the GC.
     void trace(JSTracer *trc);
--- a/js/src/jit/arm/Bailouts-arm.cpp
+++ b/js/src/jit/arm/Bailouts-arm.cpp
@@ -72,17 +72,17 @@ static_assert((sizeof(BailoutStack) % 8)
 BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator &activations,
                                    BailoutStack *bailout)
   : machine_(bailout->machine())
 {
     uint8_t *sp = bailout->parentStackPointer();
     framePointer_ = sp + bailout->frameSize();
     topFrameSize_ = framePointer_ - sp;
 
-    JSScript *script = ScriptFromCalleeToken(((IonJSFrameLayout *) framePointer_)->calleeToken());
+    JSScript *script = ScriptFromCalleeToken(((JitFrameLayout *) framePointer_)->calleeToken());
     JitActivation *activation = activations.activation()->asJit();
     if (activation->cx()->isForkJoinContext())
         topIonScript_ = script->parallelIonScript();
     else
         topIonScript_ = script->ionScript();
 
     attachOnJitActivation(activations);
 
--- a/js/src/jit/arm/BaselineHelpers-arm.h
+++ b/js/src/jit/arm/BaselineHelpers-arm.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_BaselineHelpers_arm_h
 #define jit_arm_BaselineHelpers_arm_h
 
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 // Distance from sp to the top Value inside an IC stub (no return address on the stack on ARM).
 static const size_t ICStackValueOffset = 0;
 
 inline void
--- a/js/src/jit/arm/BaselineIC-arm.cpp
+++ b/js/src/jit/arm/BaselineIC-arm.cpp
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
-#include "jit/IonLinker.h"
+#include "jit/Linker.h"
 
 using namespace js;
 using namespace js::jit;
 
 namespace js {
 namespace jit {
 
 // ICCompare_Int32
--- a/js/src/jit/arm/BaselineRegisters-arm.h
+++ b/js/src/jit/arm/BaselineRegisters-arm.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_BaselineRegisters_arm_h
 #define jit_arm_BaselineRegisters_arm_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 // r15 = program-counter
 // r14 = link-register
 
 // r13 = stack-pointer
--- a/js/src/jit/arm/CodeGenerator-arm.cpp
+++ b/js/src/jit/arm/CodeGenerator-arm.cpp
@@ -8,18 +8,18 @@
 
 #include "mozilla/MathAlgorithms.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 #include "jsnum.h"
 
 #include "jit/CodeGenerator.h"
-#include "jit/IonFrames.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "vm/Shape.h"
 #include "vm/TraceLogging.h"
 
 #include "jsscriptinlines.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
@@ -1069,17 +1069,17 @@ CodeGeneratorARM::toMoveOperand(const LA
     int32_t offset = ToStackOffset(a);
     MOZ_ASSERT((offset & 3) == 0);
     return MoveOperand(StackPointer, offset);
 }
 
 class js::jit::OutOfLineTableSwitch : public OutOfLineCodeBase<CodeGeneratorARM>
 {
     MTableSwitch *mir_;
-    Vector<CodeLabel, 8, IonAllocPolicy> codeLabels_;
+    Vector<CodeLabel, 8, JitAllocPolicy> codeLabels_;
 
     bool accept(CodeGeneratorARM *codegen) {
         return codegen->visitOutOfLineTableSwitch(this);
     }
 
   public:
     OutOfLineTableSwitch(TempAllocator &alloc, MTableSwitch *mir)
       : mir_(mir),
--- a/js/src/jit/arm/MacroAssembler-arm.cpp
+++ b/js/src/jit/arm/MacroAssembler-arm.cpp
@@ -8,17 +8,17 @@
 
 #include "mozilla/Casting.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/arm/Simulator-arm.h"
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/MoveEmitter.h"
 
 using namespace js;
 using namespace jit;
 
 using mozilla::Abs;
 using mozilla::BitwiseCast;
 
@@ -1780,17 +1780,17 @@ MacroAssemblerARMCompat::buildFakeExitFr
 
     // Consume an additional 4 bytes. The start of the next instruction will
     // then be 8 bytes after the instruction for Push(pc); this offset can
     // therefore be fed to the safepoint.
     ma_nop();
     uint32_t pseudoReturnOffset = currentOffset();
     leaveNoPool();
 
-    MOZ_ASSERT(framePushed() == initialDepth + IonExitFrameLayout::Size());
+    MOZ_ASSERT(framePushed() == initialDepth + ExitFrameLayout::Size());
     MOZ_ASSERT(pseudoReturnOffset - offsetBeforePush == 8);
 
     *offset = pseudoReturnOffset;
     return true;
 }
 
 bool
 MacroAssemblerARMCompat::buildOOLFakeExitFrame(void *fakeReturnAddr)
@@ -1805,34 +1805,34 @@ MacroAssemblerARMCompat::buildOOLFakeExi
 }
 
 void
 MacroAssemblerARMCompat::callWithExitFrame(Label *target)
 {
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor)); // descriptor
 
-    ma_callIonHalfPush(target);
+    ma_callJitHalfPush(target);
 }
 
 void
 MacroAssemblerARMCompat::callWithExitFrame(JitCode *target)
 {
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor)); // descriptor
 
     addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);
     RelocStyle rs;
     if (HasMOVWT())
         rs = L_MOVWT;
     else
         rs = L_LDR;
 
     ma_movPatchable(ImmPtr(target->raw()), ScratchRegister, Always, rs);
-    ma_callIonHalfPush(ScratchRegister);
+    ma_callJitHalfPush(ScratchRegister);
 }
 
 void
 MacroAssemblerARMCompat::callWithExitFrame(JitCode *target, Register dynStack)
 {
     ma_add(Imm32(framePushed()), dynStack);
     makeFrameDescriptor(dynStack, JitFrame_IonJS);
     Push(dynStack); // descriptor
@@ -1840,35 +1840,35 @@ MacroAssemblerARMCompat::callWithExitFra
     addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);
     RelocStyle rs;
     if (HasMOVWT())
         rs = L_MOVWT;
     else
         rs = L_LDR;
 
     ma_movPatchable(ImmPtr(target->raw()), ScratchRegister, Always, rs);
-    ma_callIonHalfPush(ScratchRegister);
-}
-
-void
-MacroAssemblerARMCompat::callIon(Register callee)
+    ma_callJitHalfPush(ScratchRegister);
+}
+
+void
+MacroAssemblerARMCompat::callJit(Register callee)
 {
     MOZ_ASSERT((framePushed() & 3) == 0);
     if ((framePushed() & 7) == 4) {
-        ma_callIonHalfPush(callee);
+        ma_callJitHalfPush(callee);
     } else {
         adjustFrame(sizeof(void*));
-        ma_callIon(callee);
+        ma_callJit(callee);
     }
 }
 
 void
 MacroAssemblerARMCompat::callJitFromAsmJS(Register callee)
 {
-    ma_callIonNoPush(callee);
+    ma_callJitNoPush(callee);
 
     // The JIT ABI has the callee pop the return address off the stack.
     // The asm.js caller assumes that the call leaves sp unchanged, so bump
     // the stack.
     subPtr(Imm32(sizeof(void*)), sp);
 }
 
 void
@@ -3705,46 +3705,46 @@ MacroAssemblerARMCompat::storeTypeTag(Im
 // address of the instruction after the call in the register.
 //
 // Also ION is breaking the ARM EABI here (sort of). The ARM EABI says that a
 // function call should move the pc into the link register, then branch to the
 // function, and *sp is data that is owned by the caller, not the callee. The
 // ION ABI says *sp should be the address that we will return to when leaving
 // this function.
 void
-MacroAssemblerARM::ma_callIon(const Register r)
+MacroAssemblerARM::ma_callJit(const Register r)
 {
     // When the stack is 8 byte aligned, we want to decrement sp by 8, and write
     // pc + 8 into the new sp. When we return from this call, sp will be its
     // present value minus 4.
     as_sub(sp, sp, Imm8(4));
     as_blx(r);
 }
 void
-MacroAssemblerARM::ma_callIonNoPush(const Register r)
+MacroAssemblerARM::ma_callJitNoPush(const Register r)
 {
     // Since we just write the return address into the stack, which is popped on
     // return, the net effect is removing 4 bytes from the stack.
 
     // Bug 1103108: remove this function, and refactor all uses.
     as_add(sp, sp, Imm8(4));
     as_blx(r);
 }
 
 void
-MacroAssemblerARM::ma_callIonHalfPush(const Register r)
+MacroAssemblerARM::ma_callJitHalfPush(const Register r)
 {
     // The stack is unaligned by 4 bytes. We push the pc to the stack to align
     // the stack before the call, when we return the pc is poped and the stack
     // is restored to its unaligned state.
     as_blx(r);
 }
 
 void
-MacroAssemblerARM::ma_callIonHalfPush(Label *label)
+MacroAssemblerARM::ma_callJitHalfPush(Label *label)
 {
     // The stack is unaligned by 4 bytes. The callee will push the lr to the stack to align
     // the stack after the call, when we return the pc is poped and the stack
     // is restored to its unaligned state.
 
     // leave the stack as-is so the callee-side can push when necessary.
 
     as_bl(label, Always);
@@ -4214,17 +4214,17 @@ MacroAssemblerARMCompat::handleFailureWi
     ma_sub(Imm32(size), sp);
     ma_mov(sp, r0);
 
     // Ask for an exception handler.
     setupUnalignedABICall(1, r1);
     passABIArg(r0);
     callWithABI(handler);
 
-    JitCode *excTail = GetIonContext()->runtime->jitRuntime()->getExceptionTail();
+    JitCode *excTail = GetJitContext()->runtime->jitRuntime()->getExceptionTail();
     branch(excTail);
 }
 
 void
 MacroAssemblerARMCompat::handleFailureWithHandlerTail()
 {
     Label entryFrame;
     Label catch_;
@@ -4693,17 +4693,17 @@ MacroAssemblerARMCompat::jumpWithPatch(R
 void
 MacroAssemblerARMCompat::branchPtrInNurseryRange(Condition cond, Register ptr, Register temp,
                                                  Label *label)
 {
     MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
     MOZ_ASSERT(ptr != temp);
     MOZ_ASSERT(ptr != secondScratchReg_);
 
-    const Nursery &nursery = GetIonContext()->runtime->gcNursery();
+    const Nursery &nursery = GetJitContext()->runtime->gcNursery();
     uintptr_t startChunk = nursery.start() >> Nursery::ChunkShift;
 
     ma_mov(Imm32(startChunk), secondScratchReg_);
     as_rsb(secondScratchReg_, secondScratchReg_, lsr(ptr, Nursery::ChunkShift));
     branch32(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
               secondScratchReg_, Imm32(nursery.numChunks()), label);
 }
 
--- a/js/src/jit/arm/MacroAssembler-arm.h
+++ b/js/src/jit/arm/MacroAssembler-arm.h
@@ -9,17 +9,17 @@
 
 #include "mozilla/DebugOnly.h"
 
 #include "jsopcode.h"
 
 #include "jit/arm/Assembler-arm.h"
 #include "jit/AtomicOp.h"
 #include "jit/IonCaches.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/MoveResolver.h"
 
 using mozilla::DebugOnly;
 
 namespace js {
 namespace jit {
 
 static Register CallReg = ip;
@@ -396,25 +396,25 @@ class MacroAssemblerARM : public Assembl
     BufferOffset ma_vldr(VFPRegister src, Register base, Register index, int32_t shift = defaultShift, Condition cc = Always);
 
     BufferOffset ma_vstr(VFPRegister src, VFPAddr addr, Condition cc = Always);
     BufferOffset ma_vstr(VFPRegister src, const Operand &addr, Condition cc = Always);
 
     BufferOffset ma_vstr(VFPRegister src, Register base, Register index, int32_t shift = defaultShift, Condition cc = Always);
     // Calls an Ion function, assumes that the stack is untouched (8 byte
     // aligned).
-    void ma_callIon(const Register reg);
+    void ma_callJit(const Register reg);
     // Calls an Ion function, assuming that sp has already been decremented.
-    void ma_callIonNoPush(const Register reg);
+    void ma_callJitNoPush(const Register reg);
     // Calls an ion function, assuming that the stack is currently not 8 byte
     // aligned.
-    void ma_callIonHalfPush(const Register reg);
+    void ma_callJitHalfPush(const Register reg);
     // Calls an ion function, assuming that the stack is currently not 8 byte
     // aligned.
-    void ma_callIonHalfPush(Label *label);
+    void ma_callJitHalfPush(Label *label);
 
     void ma_call(ImmPtr dest);
 
     // Float registers can only be loaded/stored in continuous runs when using
     // vstm/vldm. This function breaks set into continuous runs and loads/stores
     // them at [rm]. rm will be modified and left in a state logically suitable
     // for the next load/store. Returns the offset from [dm] for the logical
     // next load/store.
@@ -574,17 +574,17 @@ class MacroAssemblerARMCompat : public M
         addPendingJump(bo, ImmPtr(c->raw()), Relocation::JITCODE);
         RelocStyle rs;
         if (HasMOVWT())
             rs = L_MOVWT;
         else
             rs = L_LDR;
 
         ma_movPatchable(ImmPtr(c->raw()), ScratchRegister, Always, rs);
-        ma_callIonHalfPush(ScratchRegister);
+        ma_callJitHalfPush(ScratchRegister);
     }
     void call(const CallSiteDesc &desc, const Register reg) {
         call(reg);
         append(desc, currentOffset(), framePushed_);
     }
     void call(const CallSiteDesc &desc, Label *label) {
         call(label);
         append(desc, currentOffset(), framePushed_);
@@ -1285,19 +1285,19 @@ class MacroAssemblerARMCompat : public M
     // Builds an exit frame on the stack, with a return address to an internal
     // non-function. Returns offset to be passed to markSafepointAt().
     bool buildFakeExitFrame(Register scratch, uint32_t *offset);
 
     void callWithExitFrame(Label *target);
     void callWithExitFrame(JitCode *target);
     void callWithExitFrame(JitCode *target, Register dynStack);
 
-    // Makes an Ion call using the only two methods that it is sane for
+    // Makes a call using the only two methods that it is sane for
     // independent code to make a call.
-    void callIon(Register callee);
+    void callJit(Register callee);
     void callJitFromAsmJS(Register callee);
 
     void reserveStack(uint32_t amount);
     void freeStack(uint32_t amount);
     void freeStack(Register amount);
 
     void add32(Register src, Register dest);
     void add32(Imm32 imm, Register dest);
--- a/js/src/jit/arm/MoveEmitter-arm.h
+++ b/js/src/jit/arm/MoveEmitter-arm.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_MoveEmitter_arm_h
 #define jit_arm_MoveEmitter_arm_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MoveResolver.h"
 
 namespace js {
 namespace jit {
 
 class CodeGenerator;
 
 class MoveEmitterARM
--- a/js/src/jit/arm/Trampoline-arm.cpp
+++ b/js/src/jit/arm/Trampoline-arm.cpp
@@ -3,20 +3,20 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jscompartment.h"
 
 #include "jit/arm/BaselineHelpers-arm.h"
 #include "jit/Bailouts.h"
-#include "jit/IonFrames.h"
-#include "jit/IonLinker.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/ParallelFunctions.h"
 #include "jit/VMFunctions.h"
 
 #include "jit/ExecutionMode-inl.h"
 
@@ -259,17 +259,17 @@ JitRuntime::generateEnterJIT(JSContext *
         masm.ma_sub(sp, scratch, sp);
 
         // Enter exit frame.
         masm.addPtr(Imm32(BaselineFrame::Size() + BaselineFrame::FramePointerOffset), scratch);
         masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
         masm.push(scratch);
         masm.push(Imm32(0)); // Fake return address.
         // No GC things to mark on the stack, push a bare token.
-        masm.enterFakeExitFrame(IonExitFrameLayout::BareToken());
+        masm.enterFakeExitFrame(ExitFrameLayout::BareToken());
 
         masm.push(framePtr); // BaselineFrame
         masm.push(r0); // jitcode
 
         masm.setupUnalignedABICall(3, scratch);
         masm.passABIArg(r11); // BaselineFrame
         masm.passABIArg(OsrFrameReg); // InterpreterFrame
         masm.passABIArg(numStackValues);
@@ -277,17 +277,17 @@ JitRuntime::generateEnterJIT(JSContext *
 
         Register jitcode = regs.takeAny();
         masm.pop(jitcode);
         masm.pop(framePtr);
 
         MOZ_ASSERT(jitcode != ReturnReg);
 
         Label error;
-        masm.addPtr(Imm32(IonExitFrameLayout::SizeWithFooter()), sp);
+        masm.addPtr(Imm32(ExitFrameLayout::SizeWithFooter()), sp);
         masm.addPtr(Imm32(BaselineFrame::Size()), framePtr);
         masm.branchIfFalseBool(ReturnReg, &error);
 
         masm.jump(jitcode);
 
         // OOM: Load error value, discard return address and previous frame
         // pointer and return.
         masm.bind(&error);
@@ -298,30 +298,30 @@ JitRuntime::generateEnterJIT(JSContext *
 
         masm.bind(&notOsr);
         // Load the scope chain in R1.
         MOZ_ASSERT(R1.scratchReg() != r0);
         masm.loadPtr(Address(r11, offsetof(EnterJITStack, scopeChain)), R1.scratchReg());
     }
 
     // Call the function.
-    masm.ma_callIonNoPush(r0);
+    masm.ma_callJitNoPush(r0);
 
     if (type == EnterJitBaseline) {
         // Baseline OSR will return here.
         masm.bind(&returnLabel);
     }
 
     // The top of the stack now points to the address of the field following the
     // return address because the return address is popped for the return, so we
     // need to remove the size of the return address field.
     aasm->as_sub(sp, sp, Imm8(4));
 
     // Load off of the stack the size of our local stack.
-    masm.loadPtr(Address(sp, IonJSFrameLayout::offsetOfDescriptor()), r5);
+    masm.loadPtr(Address(sp, JitFrameLayout::offsetOfDescriptor()), r5);
     aasm->as_add(sp, sp, lsr(r5, FRAMESIZE_SHIFT));
 
     // Store the returned value into the slot_vp
     masm.loadPtr(slot_vp, r5);
     masm.storeValue(JSReturnOperand, Address(r5, 0));
 
     // :TODO: Optimize storeValue with:
     // We're using a load-double here. In order for that to work, the data needs
@@ -421,20 +421,20 @@ JitRuntime::generateArgumentsRectifier(J
     MacroAssembler masm(cx);
     masm.pushReturnAddress();
 
     // ArgumentsRectifierReg contains the |nargs| pushed onto the current frame.
     // Including |this|, there are (|nargs| + 1) arguments to copy.
     MOZ_ASSERT(ArgumentsRectifierReg == r8);
 
     // Copy number of actual arguments into r0.
-    masm.ma_ldr(DTRAddr(sp, DtrOffImm(IonRectifierFrameLayout::offsetOfNumActualArgs())), r0);
+    masm.ma_ldr(DTRAddr(sp, DtrOffImm(RectifierFrameLayout::offsetOfNumActualArgs())), r0);
 
     // Load the number of |undefined|s to push into r6.
-    masm.ma_ldr(DTRAddr(sp, DtrOffImm(IonRectifierFrameLayout::offsetOfCalleeToken())), r1);
+    masm.ma_ldr(DTRAddr(sp, DtrOffImm(RectifierFrameLayout::offsetOfCalleeToken())), r1);
     masm.ma_and(Imm32(CalleeTokenMask), r1, r6);
     masm.ma_ldrh(EDtrAddr(r6, EDtrOffImm(JSFunction::offsetOfNargs())), r6);
 
     masm.ma_sub(r6, r8, r2);
 
     masm.moveValue(UndefinedValue(), r5, r4);
 
     masm.ma_mov(sp, r3); // Save %sp.
@@ -448,17 +448,17 @@ JitRuntime::generateArgumentsRectifier(J
         masm.ma_sub(r2, Imm32(1), r2, SetCond);
 
         masm.ma_b(&undefLoopTop, Assembler::NonZero);
     }
 
     // Get the topmost argument.
 
     masm.ma_alu(r3, lsl(r8, 3), r3, OpAdd); // r3 <- r3 + nargs * 8
-    masm.ma_add(r3, Imm32(sizeof(IonRectifierFrameLayout)), r3);
+    masm.ma_add(r3, Imm32(sizeof(RectifierFrameLayout)), r3);
 
     // Push arguments, |nargs| + 1 times (to include |this|).
     {
         Label copyLoopTop;
         masm.bind(&copyLoopTop);
         masm.ma_dataTransferN(IsLoad, 64, true, r3, Imm32(-8), r4, PostIndex);
         masm.ma_dataTransferN(IsStore, 64, true, sp, Imm32(-8), r4, PreIndex);
 
@@ -468,27 +468,27 @@ JitRuntime::generateArgumentsRectifier(J
 
     // translate the framesize from values into bytes
     masm.ma_add(r6, Imm32(1), r6);
     masm.ma_lsl(Imm32(3), r6, r6);
 
     // Construct sizeDescriptor.
     masm.makeFrameDescriptor(r6, JitFrame_Rectifier);
 
-    // Construct IonJSFrameLayout.
+    // Construct JitFrameLayout.
     masm.ma_push(r0); // actual arguments.
     masm.ma_push(r1); // callee token
     masm.ma_push(r6); // frame descriptor.
 
     // Call the target function.
     // Note that this code assumes the function is JITted.
     masm.andPtr(Imm32(CalleeTokenMask), r1);
     masm.ma_ldr(DTRAddr(r1, DtrOffImm(JSFunction::offsetOfNativeOrScript())), r3);
     masm.loadBaselineOrIonRaw(r3, r3, mode, nullptr);
-    masm.ma_callIonHalfPush(r3);
+    masm.ma_callJitHalfPush(r3);
 
     uint32_t returnOffset = masm.currentOffset();
 
     // arg1
     //  ...
     // argN
     // num actual args
     // callee token
@@ -755,17 +755,17 @@ JitRuntime::generateVMWrapper(JSContext 
 
     masm.enterExitFrameAndLoadContext(&f, cxreg, regs.getAny(), f.executionMode);
 
     // Save the base of the argument set stored on the stack.
     Register argsBase = InvalidReg;
     if (f.explicitArgs) {
         argsBase = r5;
         regs.take(argsBase);
-        masm.ma_add(sp, Imm32(IonExitFrameLayout::SizeWithFooter()), argsBase);
+        masm.ma_add(sp, Imm32(ExitFrameLayout::SizeWithFooter()), argsBase);
     }
 
     // Reserve space for the outparameter.
     Register outReg = InvalidReg;
     switch (f.outParam) {
       case Type_Value:
         outReg = r4;
         regs.take(outReg);
@@ -880,17 +880,17 @@ JitRuntime::generateVMWrapper(JSContext 
         masm.freeStack(sizeof(double));
         break;
 
       default:
         MOZ_ASSERT(f.outParam == Type_Void);
         break;
     }
     masm.leaveExitFrame();
-    masm.retn(Imm32(sizeof(IonExitFrameLayout) +
+    masm.retn(Imm32(sizeof(ExitFrameLayout) +
                     f.explicitStackSlots() * sizeof(void *) +
                     f.extraValuesToPop * sizeof(Value)));
 
     Linker linker(masm);
     AutoFlushICache afc("VMWrapper");
     JitCode *wrapper = linker.newCode<NoGC>(cx, OTHER_CODE);
     if (!wrapper)
         return nullptr;
--- a/js/src/jit/mips/Bailouts-mips.cpp
+++ b/js/src/jit/mips/Bailouts-mips.cpp
@@ -15,17 +15,17 @@ using namespace js::jit;
 BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator &activations,
                                    BailoutStack *bailout)
   : machine_(bailout->machine())
 {
     uint8_t *sp = bailout->parentStackPointer();
     framePointer_ = sp + bailout->frameSize();
     topFrameSize_ = framePointer_ - sp;
 
-    JSScript *script = ScriptFromCalleeToken(((IonJSFrameLayout *) framePointer_)->calleeToken());
+    JSScript *script = ScriptFromCalleeToken(((JitFrameLayout *) framePointer_)->calleeToken());
     JitActivation *activation = activations.activation()->asJit();
     if (activation->cx()->isForkJoinContext())
         topIonScript_ = script->parallelIonScript();
     else
         topIonScript_ = script->ionScript();
 
     attachOnJitActivation(activations);
 
--- a/js/src/jit/mips/BaselineHelpers-mips.h
+++ b/js/src/jit/mips/BaselineHelpers-mips.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_mips_BaselineHelpers_mips_h
 #define jit_mips_BaselineHelpers_mips_h
 
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 // Distance from sp to the top Value inside an IC stub (no return address on
 // the stack on MIPS).
 static const size_t ICStackValueOffset = 0;
 
@@ -94,19 +94,19 @@ EmitTailCallVM(JitCode *target, MacroAss
     masm.storePtr(t7, Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfFrameSize()));
 
     // Push frame descriptor and perform the tail call.
     // BaselineTailCallReg (ra) already contains the return address (as we
     // keep it there through the stub calls), but the VMWrapper code being
     // called expects the return address to also be pushed on the stack.
     MOZ_ASSERT(BaselineTailCallReg == ra);
     masm.makeFrameDescriptor(t6, JitFrame_BaselineJS);
-    masm.subPtr(Imm32(sizeof(IonCommonFrameLayout)), StackPointer);
-    masm.storePtr(t6, Address(StackPointer, IonCommonFrameLayout::offsetOfDescriptor()));
-    masm.storePtr(ra, Address(StackPointer, IonCommonFrameLayout::offsetOfReturnAddress()));
+    masm.subPtr(Imm32(sizeof(CommonFrameLayout)), StackPointer);
+    masm.storePtr(t6, Address(StackPointer, CommonFrameLayout::offsetOfDescriptor()));
+    masm.storePtr(ra, Address(StackPointer, CommonFrameLayout::offsetOfReturnAddress()));
 
     masm.branch(target);
 }
 
 inline void
 EmitCreateStubFrameDescriptor(MacroAssembler &masm, Register reg)
 {
     // Compute stub frame size. We have to add two pointers: the stub reg and
--- a/js/src/jit/mips/BaselineIC-mips.cpp
+++ b/js/src/jit/mips/BaselineIC-mips.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jsiter.h"
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
-#include "jit/IonLinker.h"
+#include "jit/Linker.h"
 
 #include "jsboolinlines.h"
 
 using namespace js;
 using namespace js::jit;
 
 namespace js {
 namespace jit {
--- a/js/src/jit/mips/BaselineRegisters-mips.h
+++ b/js/src/jit/mips/BaselineRegisters-mips.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_mips_BaselineRegisters_mips_h
 #define jit_mips_BaselineRegisters_mips_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = s5;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = sp;
 
 static MOZ_CONSTEXPR_VAR ValueOperand R0(a3, a2);
--- a/js/src/jit/mips/CodeGenerator-mips.cpp
+++ b/js/src/jit/mips/CodeGenerator-mips.cpp
@@ -8,18 +8,18 @@
 
 #include "mozilla/MathAlgorithms.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 #include "jsnum.h"
 
 #include "jit/CodeGenerator.h"
-#include "jit/IonFrames.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "vm/Shape.h"
 #include "vm/TraceLogging.h"
 
 #include "jsscriptinlines.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
--- a/js/src/jit/mips/MacroAssembler-mips.cpp
+++ b/js/src/jit/mips/MacroAssembler-mips.cpp
@@ -7,17 +7,17 @@
 #include "jit/mips/MacroAssembler-mips.h"
 
 #include "mozilla/DebugOnly.h"
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineRegisters.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/mips/Simulator-mips.h"
 #include "jit/MoveEmitter.h"
 
 using namespace js;
 using namespace jit;
 
 using mozilla::Abs;
 
@@ -1485,17 +1485,17 @@ MacroAssemblerMIPSCompat::buildFakeExitF
 
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor));
     Push(scratch);
 
     bind(cl.src());
     *offset = currentOffset();
 
-    MOZ_ASSERT(framePushed() == initialDepth + IonExitFrameLayout::Size());
+    MOZ_ASSERT(framePushed() == initialDepth + ExitFrameLayout::Size());
     return addCodeLabel(cl);
 }
 
 bool
 MacroAssemblerMIPSCompat::buildOOLFakeExitFrame(void *fakeReturnAddr)
 {
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
 
@@ -1506,57 +1506,57 @@ MacroAssemblerMIPSCompat::buildOOLFakeEx
 }
 
 void
 MacroAssemblerMIPSCompat::callWithExitFrame(Label *target)
 {
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor)); // descriptor
 
-    ma_callIonHalfPush(target);
+    ma_callJitHalfPush(target);
 }
 
 void
 MacroAssemblerMIPSCompat::callWithExitFrame(JitCode *target)
 {
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor)); // descriptor
 
     addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);
     ma_liPatchable(ScratchRegister, ImmPtr(target->raw()));
-    ma_callIonHalfPush(ScratchRegister);
+    ma_callJitHalfPush(ScratchRegister);
 }
 
 void
 MacroAssemblerMIPSCompat::callWithExitFrame(JitCode *target, Register dynStack)
 {
     ma_addu(dynStack, dynStack, Imm32(framePushed()));
     makeFrameDescriptor(dynStack, JitFrame_IonJS);
     Push(dynStack); // descriptor
 
     addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);
     ma_liPatchable(ScratchRegister, ImmPtr(target->raw()));
-    ma_callIonHalfPush(ScratchRegister);
-}
-
-void
-MacroAssemblerMIPSCompat::callIon(Register callee)
+    ma_callJitHalfPush(ScratchRegister);
+}
+
+void
+MacroAssemblerMIPSCompat::callJit(Register callee)
 {
     MOZ_ASSERT((framePushed() & 3) == 0);
     if ((framePushed() & 7) == 4) {
-        ma_callIonHalfPush(callee);
+        ma_callJitHalfPush(callee);
     } else {
         adjustFrame(sizeof(uint32_t));
-        ma_callIon(callee);
+        ma_callJit(callee);
     }
 }
 void
 MacroAssemblerMIPSCompat::callJitFromAsmJS(Register callee)
 {
-    ma_callIonNoPush(callee);
+    ma_callJitNoPush(callee);
 
     // The JIT ABI has the callee pop the return address off the stack.
     // The asm.js caller assumes that the call leaves sp unchanged, so bump
     // the stack.
     subPtr(Imm32(sizeof(void*)), StackPointer);
 }
 
 void
@@ -3117,49 +3117,49 @@ MacroAssemblerMIPSCompat::storeTypeTag(I
     MOZ_ASSERT(dest.offset == 0);
 
     computeScaledAddress(dest, SecondScratchReg);
     ma_li(ScratchRegister, tag);
     as_sw(ScratchRegister, SecondScratchReg, TAG_OFFSET);
 }
 
 void
-MacroAssemblerMIPS::ma_callIonNoPush(const Register r)
+MacroAssemblerMIPS::ma_callJitNoPush(const Register r)
 {
     // This is a MIPS hack to push return address during jalr delay slot.
     as_jalr(r);
     as_sw(ra, StackPointer, 0);
 }
 
 // This macrosintruction calls the ion code and pushes the return address to
 // the stack in the case when stack is alligned.
 void
-MacroAssemblerMIPS::ma_callIon(const Register r)
+MacroAssemblerMIPS::ma_callJit(const Register r)
 {
     // This is a MIPS hack to push return address during jalr delay slot.
     as_addiu(StackPointer, StackPointer, -2 * sizeof(intptr_t));
     as_jalr(r);
     as_sw(ra, StackPointer, 0);
 }
 
 // This macrosintruction calls the ion code and pushes the return address to
 // the stack in the case when stack is not alligned.
 void
-MacroAssemblerMIPS::ma_callIonHalfPush(const Register r)
+MacroAssemblerMIPS::ma_callJitHalfPush(const Register r)
 {
     // This is a MIPS hack to push return address during jalr delay slot.
     as_addiu(StackPointer, StackPointer, -sizeof(intptr_t));
     as_jalr(r);
     as_sw(ra, StackPointer, 0);
 }
 
 // This macrosintruction calls the ion code and pushes the return address to
 // the stack in the case when stack is not alligned.
 void
-MacroAssemblerMIPS::ma_callIonHalfPush(Label *label)
+MacroAssemblerMIPS::ma_callJitHalfPush(Label *label)
 {
     // This is a MIPS hack to push return address during jalr delay slot.
     as_addiu(StackPointer, StackPointer, -sizeof(intptr_t));
     ma_bal(label, DontFillDelaySlot);
     as_sw(ra, StackPointer, 0);
 }
 
 void
@@ -3533,17 +3533,17 @@ MacroAssemblerMIPSCompat::handleFailureW
     ma_subu(StackPointer, StackPointer, Imm32(size));
     ma_move(a0, StackPointer); // Use a0 since it is a first function argument
 
     // Ask for an exception handler.
     setupUnalignedABICall(1, a1);
     passABIArg(a0);
     callWithABI(handler);
 
-    JitCode *excTail = GetIonContext()->runtime->jitRuntime()->getExceptionTail();
+    JitCode *excTail = GetJitContext()->runtime->jitRuntime()->getExceptionTail();
     branch(excTail);
 }
 
 void
 MacroAssemblerMIPSCompat::handleFailureWithHandlerTail()
 {
     Label entryFrame;
     Label catch_;
@@ -3646,17 +3646,17 @@ MacroAssemblerMIPSCompat::toggledCall(Ji
 void
 MacroAssemblerMIPSCompat::branchPtrInNurseryRange(Condition cond, Register ptr, Register temp,
                                                   Label *label)
 {
     MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
     MOZ_ASSERT(ptr != temp);
     MOZ_ASSERT(ptr != SecondScratchReg);
 
-    const Nursery &nursery = GetIonContext()->runtime->gcNursery();
+    const Nursery &nursery = GetJitContext()->runtime->gcNursery();
     movePtr(ImmWord(-ptrdiff_t(nursery.start())), SecondScratchReg);
     addPtr(ptr, SecondScratchReg);
     branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
               SecondScratchReg, Imm32(nursery.nurserySize()), label);
 }
 
 void
 MacroAssemblerMIPSCompat::branchValueIsNurseryObject(Condition cond, ValueOperand value,
--- a/js/src/jit/mips/MacroAssembler-mips.h
+++ b/js/src/jit/mips/MacroAssembler-mips.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_mips_MacroAssembler_mips_h
 #define jit_mips_MacroAssembler_mips_h
 
 #include "jsopcode.h"
 
 #include "jit/AtomicOp.h"
 #include "jit/IonCaches.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/mips/Assembler-mips.h"
 #include "jit/MoveResolver.h"
 
 namespace js {
 namespace jit {
 
 enum LoadStoreSize
 {
@@ -298,22 +298,22 @@ class MacroAssemblerMIPS : public Assemb
     Condition ma_cmp(Register rd, Register lhs, Register rhs, Condition c);
 
     void compareFloatingPoint(FloatFormat fmt, FloatRegister lhs, FloatRegister rhs,
                               DoubleCondition c, FloatTestKind *testKind,
                               FPConditionBit fcc = FCC0);
 
   public:
     // calls an Ion function, assumes that the stack is untouched (8 byte alinged)
-    void ma_callIon(const Register reg);
+    void ma_callJit(const Register reg);
     // callso an Ion function, assuming that sp has already been decremented
-    void ma_callIonNoPush(const Register reg);
+    void ma_callJitNoPush(const Register reg);
     // calls an ion function, assuming that the stack is currently not 8 byte aligned
-    void ma_callIonHalfPush(const Register reg);
-    void ma_callIonHalfPush(Label *label);
+    void ma_callJitHalfPush(const Register reg);
+    void ma_callJitHalfPush(Label *label);
 
     void ma_call(ImmPtr dest);
 
     void ma_jump(ImmPtr dest);
 
     void ma_cmp_set(Register dst, Register lhs, Register rhs, Condition c);
     void ma_cmp_set(Register dst, Register lhs, Imm32 imm, Condition c);
     void ma_cmp_set(Register dst, Register lhs, ImmPtr imm, Condition c) {
@@ -414,29 +414,29 @@ class MacroAssemblerMIPSCompat : public 
     void call(AsmJSImmPtr imm) {
         movePtr(imm, CallReg);
         call(CallReg);
     }
     void call(JitCode *c) {
         BufferOffset bo = m_buffer.nextOffset();
         addPendingJump(bo, ImmPtr(c->raw()), Relocation::JITCODE);
         ma_liPatchable(ScratchRegister, Imm32((uint32_t)c->raw()));
-        ma_callIonHalfPush(ScratchRegister);
+        ma_callJitHalfPush(ScratchRegister);
     }
     void call(const CallSiteDesc &desc, const Register reg) {
         call(reg);
         append(desc, currentOffset(), framePushed_);
     }
     void call(const CallSiteDesc &desc, Label *label) {
         call(label);
         append(desc, currentOffset(), framePushed_);
     }
 
     void callAndPushReturnAddress(Label *label) {
-        ma_callIonHalfPush(label);
+        ma_callJitHalfPush(label);
     }
 
     void branch(JitCode *c) {
         BufferOffset bo = m_buffer.nextOffset();
         addPendingJump(bo, ImmPtr(c->raw()), Relocation::JITCODE);
         ma_liPatchable(ScratchRegister, Imm32((uint32_t)c->raw()));
         as_jr(ScratchRegister);
         as_nop();
@@ -1132,19 +1132,19 @@ public:
     // Builds an exit frame on the stack, with a return address to an internal
     // non-function. Returns offset to be passed to markSafepointAt().
     bool buildFakeExitFrame(Register scratch, uint32_t *offset);
 
     void callWithExitFrame(Label *target);
     void callWithExitFrame(JitCode *target);
     void callWithExitFrame(JitCode *target, Register dynStack);
 
-    // Makes an Ion call using the only two methods that it is sane for
-    // indep code to make a call
-    void callIon(Register callee);
+    // Makes a call using the only two methods that it is sane for indep code
+    // to make a call.
+    void callJit(Register callee);
     void callJitFromAsmJS(Register callee);
 
     void reserveStack(uint32_t amount);
     void freeStack(uint32_t amount);
     void freeStack(Register amount);
 
     void add32(Register src, Register dest);
     void add32(Imm32 imm, Register dest);
--- a/js/src/jit/mips/MoveEmitter-mips.h
+++ b/js/src/jit/mips/MoveEmitter-mips.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_mips_MoveEmitter_mips_h
 #define jit_mips_MoveEmitter_mips_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MoveResolver.h"
 
 namespace js {
 namespace jit {
 
 class CodeGenerator;
 
 class MoveEmitterMIPS
--- a/js/src/jit/mips/Trampoline-mips.cpp
+++ b/js/src/jit/mips/Trampoline-mips.cpp
@@ -2,20 +2,20 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jscompartment.h"
 
 #include "jit/Bailouts.h"
-#include "jit/IonFrames.h"
-#include "jit/IonLinker.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #include "jit/mips/Bailouts-mips.h"
 #include "jit/mips/BaselineHelpers-mips.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/ParallelFunctions.h"
 #include "jit/VMFunctions.h"
 
@@ -232,17 +232,17 @@ JitRuntime::generateEnterJIT(JSContext *
         masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
 
         // Push frame descriptor and fake return address.
         masm.reserveStack(2 * sizeof(uintptr_t));
         masm.storePtr(scratch, Address(StackPointer, sizeof(uintptr_t))); // Frame descriptor
         masm.storePtr(zero, Address(StackPointer, 0)); // fake return address
 
         // No GC things to mark, push a bare token.
-        masm.enterFakeExitFrame(IonExitFrameLayout::BareToken());
+        masm.enterFakeExitFrame(ExitFrameLayout::BareToken());
 
         masm.reserveStack(2 * sizeof(uintptr_t));
         masm.storePtr(framePtr, Address(StackPointer, sizeof(uintptr_t))); // BaselineFrame
         masm.storePtr(reg_code, Address(StackPointer, 0)); // jitcode
 
         masm.setupUnalignedABICall(3, scratch);
         masm.passABIArg(BaselineFrameReg); // BaselineFrame
         masm.passABIArg(OsrFrameReg); // InterpreterFrame
@@ -255,17 +255,17 @@ JitRuntime::generateEnterJIT(JSContext *
         regs.take(JSReturnOperand);
         regs.take(ReturnReg);
         Register jitcode = regs.takeAny();
         masm.loadPtr(Address(StackPointer, 0), jitcode);
         masm.loadPtr(Address(StackPointer, sizeof(uintptr_t)), framePtr);
         masm.freeStack(2 * sizeof(uintptr_t));
 
         Label error;
-        masm.freeStack(IonExitFrameLayout::SizeWithFooter());
+        masm.freeStack(ExitFrameLayout::SizeWithFooter());
         masm.addPtr(Imm32(BaselineFrame::Size()), framePtr);
         masm.branchIfFalseBool(ReturnReg, &error);
 
         masm.jump(jitcode);
 
         // OOM: load error value, discard return address and previous frame
         // pointer and return.
         masm.bind(&error);
@@ -277,17 +277,17 @@ JitRuntime::generateEnterJIT(JSContext *
 
         masm.bind(&notOsr);
         // Load the scope chain in R1.
         MOZ_ASSERT(R1.scratchReg() != reg_code);
         masm.loadPtr(slotScopeChain, R1.scratchReg());
     }
 
     // Call the function with pushing return address to stack.
-    masm.ma_callIonHalfPush(reg_code);
+    masm.ma_callJitHalfPush(reg_code);
 
     if (type == EnterJitBaseline) {
         // Baseline OSR will return here.
         masm.bind(returnLabel.src());
         if (!masm.addCodeLabel(returnLabel))
             return nullptr;
     }
 
@@ -395,21 +395,21 @@ JitRuntime::generateArgumentsRectifier(J
     // frame. Including |this|, there are (|nargs| + 1) arguments to copy.
     MOZ_ASSERT(ArgumentsRectifierReg == s3);
 
     Register numActArgsReg = t6;
     Register calleeTokenReg = t7;
     Register numArgsReg = t5;
 
     // Copy number of actual arguments into numActArgsReg
-    masm.loadPtr(Address(StackPointer, IonRectifierFrameLayout::offsetOfNumActualArgs()),
+    masm.loadPtr(Address(StackPointer, RectifierFrameLayout::offsetOfNumActualArgs()),
                  numActArgsReg);
 
     // Load the number of |undefined|s to push into t1.
-    masm.loadPtr(Address(StackPointer, IonRectifierFrameLayout::offsetOfCalleeToken()),
+    masm.loadPtr(Address(StackPointer, RectifierFrameLayout::offsetOfCalleeToken()),
                  calleeTokenReg);
     masm.mov(calleeTokenReg, numArgsReg);
     masm.andPtr(Imm32(CalleeTokenMask), numArgsReg);
     masm.load16ZeroExtend(Address(numArgsReg, JSFunction::offsetOfNargs()), numArgsReg);
 
     masm.ma_subu(t1, numArgsReg, s3);
 
     masm.moveValue(UndefinedValue(), ValueOperand(t3, t4));
@@ -426,17 +426,17 @@ JitRuntime::generateArgumentsRectifier(J
         masm.sub32(Imm32(1), t1);
 
         masm.ma_b(t1, t1, &undefLoopTop, Assembler::NonZero, ShortJump);
     }
 
     // Get the topmost argument.
     masm.ma_sll(t0, s3, Imm32(3)); // t0 <- nargs * 8
     masm.addPtr(t0, t2); // t2 <- t2(saved sp) + nargs * 8
-    masm.addPtr(Imm32(sizeof(IonRectifierFrameLayout)), t2);
+    masm.addPtr(Imm32(sizeof(RectifierFrameLayout)), t2);
 
     // Push arguments, |nargs| + 1 times (to include |this|).
     {
         Label copyLoopTop, initialSkip;
 
         masm.ma_b(&initialSkip, ShortJump);
 
         masm.bind(&copyLoopTop);
@@ -458,31 +458,31 @@ JitRuntime::generateArgumentsRectifier(J
 
     // translate the framesize from values into bytes
     masm.ma_addu(t0, numArgsReg, Imm32(1));
     masm.lshiftPtr(Imm32(3), t0);
 
     // Construct sizeDescriptor.
     masm.makeFrameDescriptor(t0, JitFrame_Rectifier);
 
-    // Construct IonJSFrameLayout.
+    // Construct JitFrameLayout.
     masm.subPtr(Imm32(3 * sizeof(uintptr_t)), StackPointer);
     // Push actual arguments.
     masm.storePtr(numActArgsReg, Address(StackPointer, 2 * sizeof(uintptr_t)));
     // Push callee token.
     masm.storePtr(calleeTokenReg, Address(StackPointer, sizeof(uintptr_t)));
     // Push frame descriptor.
     masm.storePtr(t0, Address(StackPointer, 0));
 
     // Call the target function.
     // Note that this code assumes the function is JITted.
     masm.andPtr(Imm32(CalleeTokenMask), calleeTokenReg);
     masm.loadPtr(Address(calleeTokenReg, JSFunction::offsetOfNativeOrScript()), t1);
     masm.loadBaselineOrIonRaw(t1, t1, mode, nullptr);
-    masm.ma_callIonHalfPush(t1);
+    masm.ma_callJitHalfPush(t1);
 
     uint32_t returnOffset = masm.currentOffset();
 
     // arg1
     //  ...
     // argN
     // num actual args
     // callee token
@@ -724,17 +724,17 @@ JitRuntime::generateVMWrapper(JSContext 
     // We're aligned to an exit frame, so link it up.
     masm.enterExitFrameAndLoadContext(&f, cxreg, regs.getAny(), f.executionMode);
 
     // Save the base of the argument set stored on the stack.
     Register argsBase = InvalidReg;
     if (f.explicitArgs) {
         argsBase = t1; // Use temporary register.
         regs.take(argsBase);
-        masm.ma_addu(argsBase, StackPointer, Imm32(IonExitFrameLayout::SizeWithFooter()));
+        masm.ma_addu(argsBase, StackPointer, Imm32(ExitFrameLayout::SizeWithFooter()));
     }
 
     masm.alignStackPointer();
 
     // Reserve space for the outparameter. Reserve sizeof(Value) for every
     // case so that stack stays aligned.
     uint32_t outParamSize = 0;
     switch (f.outParam) {
@@ -880,17 +880,17 @@ JitRuntime::generateVMWrapper(JSContext 
       default:
         MOZ_ASSERT(f.outParam == Type_Void);
         break;
     }
 
     masm.restoreStackPointer();
 
     masm.leaveExitFrame();
-    masm.retn(Imm32(sizeof(IonExitFrameLayout) +
+    masm.retn(Imm32(sizeof(ExitFrameLayout) +
                     f.explicitStackSlots() * sizeof(uintptr_t) +
                     f.extraValuesToPop * sizeof(Value)));
 
     Linker linker(masm);
     AutoFlushICache afc("VMWrapper");
     JitCode *wrapper = linker.newCode<NoGC>(cx, OTHER_CODE);
     if (!wrapper)
         return nullptr;
--- a/js/src/jit/none/BaselineRegisters-none.h
+++ b/js/src/jit/none/BaselineRegisters-none.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_none_BaselineRegisters_none_h
 #define jit_none_BaselineRegisters_none_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = { 0 };
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = { 0 };
 
 static MOZ_CONSTEXPR_VAR ValueOperand R0 = JSReturnOperand;
--- a/js/src/jit/none/MacroAssembler-none.h
+++ b/js/src/jit/none/MacroAssembler-none.h
@@ -185,17 +185,17 @@ class MacroAssemblerNone : public Assemb
     void setupAlignedABICall(uint32_t) { MOZ_CRASH(); }
     void setupUnalignedABICall(uint32_t, Register) { MOZ_CRASH(); }
     template <typename T> void passABIArg(T, MoveOp::Type v = MoveOp::GENERAL) { MOZ_CRASH(); }
 
     void callWithExitFrame(Label *) { MOZ_CRASH(); }
     void callWithExitFrame(JitCode *) { MOZ_CRASH(); }
     void callWithExitFrame(JitCode *, Register) { MOZ_CRASH(); }
 
-    void callIon(Register callee) { MOZ_CRASH(); }
+    void callJit(Register callee) { MOZ_CRASH(); }
     void callJitFromAsmJS(Register callee) { MOZ_CRASH(); }
 
     void nop() { MOZ_CRASH(); }
     void breakpoint() { MOZ_CRASH(); }
     void abiret() { MOZ_CRASH(); }
     void ret() { MOZ_CRASH(); }
 
     CodeOffsetLabel toggledJump(Label *) { MOZ_CRASH(); }
--- a/js/src/jit/none/MoveEmitter-none.h
+++ b/js/src/jit/none/MoveEmitter-none.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_none_MoveEmitter_none_h
 #define jit_none_MoveEmitter_none_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MoveResolver.h"
 
 namespace js {
 namespace jit {
 
 class MoveEmitterNone
 {
   public:
--- a/js/src/jit/shared/Assembler-shared.h
+++ b/js/src/jit/shared/Assembler-shared.h
@@ -7,17 +7,17 @@
 #ifndef jit_shared_Assembler_shared_h
 #define jit_shared_Assembler_shared_h
 
 #include "mozilla/PodOperations.h"
 
 #include <limits.h>
 
 #include "asmjs/AsmJSFrameIterator.h"
-#include "jit/IonAllocPolicy.h"
+#include "jit/JitAllocPolicy.h"
 #include "jit/Label.h"
 #include "jit/Registers.h"
 #include "jit/RegisterSets.h"
 #include "vm/HelperThreads.h"
 
 #if defined(JS_CODEGEN_ARM)
 #define JS_USE_LINK_REGISTER
 #endif
@@ -118,31 +118,31 @@ struct ImmWord
     explicit ImmWord(uintptr_t value) : value(value)
     { }
 };
 
 #ifdef DEBUG
 static inline bool
 IsCompilingAsmJS()
 {
-    // asm.js compilation pushes an IonContext with a null JSCompartment.
-    IonContext *ictx = MaybeGetIonContext();
-    return ictx && ictx->compartment == nullptr;
+    // asm.js compilation pushes a JitContext with a null JSCompartment.
+    JitContext *jctx = MaybeGetJitContext();
+    return jctx && jctx->compartment == nullptr;
 }
 
 static inline bool
 CanUsePointerImmediates()
 {
     if (!IsCompilingAsmJS())
         return true;
 
     // Pointer immediates can still be used with asm.js when the resulting code
     // is being profiled; the module will not be serialized in this case.
-    IonContext *ictx = MaybeGetIonContext();
-    if (ictx && ictx->runtime->profilingScripts())
+    JitContext *jctx = MaybeGetJitContext();
+    if (jctx && jctx->runtime->profilingScripts())
         return true;
 
     return false;
 }
 #endif
 
 // Pointer to be embedded as an immediate in an instruction.
 struct ImmPtr
@@ -935,17 +935,17 @@ class AssemblerShared
     }
 
     ImmGCPtr noteMaybeNurseryPtr(ImmMaybeNurseryPtr ptr) {
 #ifdef JSGC_GENERATIONAL
         if (ptr.value && gc::IsInsideNursery(ptr.value)) {
             // FIXME: Ideally we'd assert this in all cases, but PJS needs to
             //        compile IC's from off-main-thread; it will not touch
             //        nursery pointers, however.
-            MOZ_ASSERT(GetIonContext()->runtime->onMainThread());
+            MOZ_ASSERT(GetJitContext()->runtime->onMainThread());
             embedsNurseryPointers_ = true;
         }
 #endif
         return ImmGCPtr(ptr);
     }
 
     void append(const CallSiteDesc &desc, size_t currentOffset, size_t framePushed) {
         // framePushed does not include sizeof(AsmJSFrame), so add it in here (see
--- a/js/src/jit/shared/BaselineCompiler-shared.h
+++ b/js/src/jit/shared/BaselineCompiler-shared.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_shared_BaselineCompiler_shared_h
 #define jit_shared_BaselineCompiler_shared_h
 
 #include "jit/BaselineFrameInfo.h"
 #include "jit/BaselineIC.h"
 #include "jit/BytecodeAnalysis.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 class BaselineCompilerShared
 {
   protected:
     JSContext *cx;
--- a/js/src/jit/shared/CodeGenerator-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-shared.cpp
@@ -5,25 +5,25 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
 
 #include "mozilla/DebugOnly.h"
 
 #include "jit/CompactBuffer.h"
 #include "jit/IonCaches.h"
-#include "jit/IonMacroAssembler.h"
 #include "jit/JitcodeMap.h"
 #include "jit/JitSpewer.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MIR.h"
 #include "jit/MIRGenerator.h"
 #include "jit/ParallelFunctions.h"
 #include "vm/TraceLogging.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 namespace js {
 namespace jit {
@@ -52,17 +52,17 @@ CodeGeneratorShared::CodeGeneratorShared
 #endif
     lastOsiPointOffset_(0),
     nativeToBytecodeMap_(nullptr),
     nativeToBytecodeMapSize_(0),
     nativeToBytecodeTableOffset_(0),
     nativeToBytecodeNumRegions_(0),
     nativeToBytecodeScriptList_(nullptr),
     nativeToBytecodeScriptListLength_(0),
-    sps_(&GetIonContext()->runtime->spsProfiler(), &lastNotInlinedPC_),
+    sps_(&GetJitContext()->runtime->spsProfiler(), &lastNotInlinedPC_),
     osrEntryOffset_(0),
     skipArgCheckEntryOffset_(0),
 #ifdef CHECK_OSIPOINT_REGISTERS
     checkOsiPointRegisters(js_JitOptions.checkOsiPointRegisters),
 #endif
     frameDepth_(graph->paddedLocalSlotsSize() + graph->argumentsSize()),
     frameInitialAdjustment_(0)
 {
@@ -270,18 +270,18 @@ CodeGeneratorShared::dumpNativeToBytecod
 // see OffsetOfFrameSlot
 static inline int32_t
 ToStackIndex(LAllocation *a)
 {
     if (a->isStackSlot()) {
         MOZ_ASSERT(a->toStackSlot()->slot() >= 1);
         return a->toStackSlot()->slot();
     }
-    MOZ_ASSERT(-int32_t(sizeof(IonJSFrameLayout)) <= a->toArgument()->index());
-    return -int32_t(sizeof(IonJSFrameLayout) + a->toArgument()->index());
+    MOZ_ASSERT(-int32_t(sizeof(JitFrameLayout)) <= a->toArgument()->index());
+    return -int32_t(sizeof(JitFrameLayout) + a->toArgument()->index());
 }
 
 bool
 CodeGeneratorShared::encodeAllocation(LSnapshot *snapshot, MDefinition *mir,
                                       uint32_t *allocIndex)
 {
     if (mir->isBox())
         mir = mir->toBox()->getOperand(0);
@@ -995,17 +995,17 @@ CodeGeneratorShared::resetOsiPointRegs(L
 bool
 CodeGeneratorShared::callVM(const VMFunction &fun, LInstruction *ins, const Register *dynStack)
 {
     // Different execution modes have different sets of VM functions.
     MOZ_ASSERT(fun.executionMode == gen->info().executionMode());
 
     // If we're calling a function with an out parameter type of double, make
     // sure we have an FPU.
-    MOZ_ASSERT_IF(fun.outParam == Type_Double, GetIonContext()->runtime->jitSupportsFloatingPoint());
+    MOZ_ASSERT_IF(fun.outParam == Type_Double, GetJitContext()->runtime->jitSupportsFloatingPoint());
 
 #ifdef DEBUG
     if (ins->mirRaw()) {
         MOZ_ASSERT(ins->mirRaw()->isInstruction());
         MInstruction *mir = ins->mirRaw()->toInstruction();
         MOZ_ASSERT_IF(mir->needsResumePoint(), mir->resumePoint());
     }
 #endif
@@ -1043,17 +1043,17 @@ CodeGeneratorShared::callVM(const VMFunc
     else
         callOffset = masm.callWithExitFrame(wrapper);
 
     if (!markSafepointAt(callOffset, ins))
         return false;
 
     // Remove rest of the frame left on the stack. We remove the return address
     // which is implicitly poped when returning.
-    int framePop = sizeof(IonExitFrameLayout) - sizeof(void*);
+    int framePop = sizeof(ExitFrameLayout) - sizeof(void*);
 
     // Pop arguments from framePushed.
     masm.implicitPop(fun.explicitStackSlots() * sizeof(void *) + framePop);
     // Stack is:
     //    ... frame ...
 
 #ifdef JS_TRACE_LOGGING
     if (!emitTracelogStopEvent(TraceLogger::VM))
--- a/js/src/jit/shared/CodeGenerator-shared.h
+++ b/js/src/jit/shared/CodeGenerator-shared.h
@@ -4,19 +4,19 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_shared_CodeGenerator_shared_h
 #define jit_shared_CodeGenerator_shared_h
 
 #include "mozilla/Alignment.h"
 
-#include "jit/IonFrames.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/JitFrames.h"
 #include "jit/LIR.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MIRGenerator.h"
 #include "jit/MIRGraph.h"
 #include "jit/Safepoints.h"
 #include "jit/Snapshots.h"
 #include "jit/VMFunctions.h"
 #include "vm/ForkJoin.h"
 
 namespace js {
@@ -176,23 +176,23 @@ class CodeGeneratorShared : public LElem
     int32_t frameInitialAdjustment_;
 
     // Frame class this frame's size falls into (see IonFrame.h).
     FrameSizeClass frameClass_;
 
     // For arguments to the current function.
     inline int32_t ArgToStackOffset(int32_t slot) const {
         return masm.framePushed() +
-               (gen->compilingAsmJS() ? sizeof(AsmJSFrame) : sizeof(IonJSFrameLayout)) +
+               (gen->compilingAsmJS() ? sizeof(AsmJSFrame) : sizeof(JitFrameLayout)) +
                slot;
     }
 
     // For the callee of the current function.
     inline int32_t CalleeStackOffset() const {
-        return masm.framePushed() + IonJSFrameLayout::offsetOfCalleeToken();
+        return masm.framePushed() + JitFrameLayout::offsetOfCalleeToken();
     }
 
     inline int32_t SlotToStackOffset(int32_t slot) const {
         MOZ_ASSERT(slot > 0 && slot <= int32_t(graph.localSlotCount()));
         int32_t offset = masm.framePushed() - frameInitialAdjustment_ - slot;
         MOZ_ASSERT(offset >= 0);
         return offset;
     }
--- a/js/src/jit/shared/CodeGenerator-x86-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-x86-shared.cpp
@@ -6,19 +6,19 @@
 
 #include "jit/shared/CodeGenerator-x86-shared.h"
 
 #include "mozilla/DebugOnly.h"
 #include "mozilla/MathAlgorithms.h"
 
 #include "jsmath.h"
 
-#include "jit/IonFrames.h"
-#include "jit/IonLinker.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
+#include "jit/Linker.h"
 #include "jit/RangeAnalysis.h"
 #include "vm/TraceLogging.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
--- a/js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
+++ b/js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
@@ -105,23 +105,23 @@
 // for simplicity the code below is specialized for fixed 32-bit sized
 // instructions and makes no attempt to support variable length
 // instructions. The base assembler buffer which supports variable width
 // instruction is used by the x86 and x64 backends.
 
 namespace js {
 namespace jit {
 
-typedef Vector<BufferOffset, 512, OldIonAllocPolicy> LoadOffsets;
+typedef Vector<BufferOffset, 512, OldJitAllocPolicy> LoadOffsets;
 
 // The allocation unit size for pools.
 typedef int32_t PoolAllocUnit;
 
 struct Pool
-  : public OldIonAllocPolicy
+  : public OldJitAllocPolicy
 {
   private:
     // The maximum program-counter relative offset below which the instruction
     // set can encode. Different classes of intructions might support different
     // ranges but for simplicity the minimum is used here, and for the ARM this
     // is constrained to 1024 by the float load instructions.
     const size_t maxOffset_;
     // An offset to apply to program-counter relative offsets. The ARM has a
@@ -380,18 +380,18 @@ struct AssemblerBufferWithConstantPools 
     const uint32_t nopFillInst_;
     const unsigned nopFill_;
     // For inhibiting the insertion of fill NOPs in the dynamic context in which
     // they are being inserted.
     bool inhibitNops_;
 
   public:
 
-    // A unique id within each IonContext, to identify pools in the debug
-    // spew. Set by the IonMacroAssembler, see getNextAssemblerId().
+    // A unique id within each JitContext, to identify pools in the debug
+    // spew. Set by the MacroAssembler, see getNextAssemblerId().
     int id;
 
   private:
     // The buffer slices are in a double linked list. Pointers to the head and
     // tail of this list:
     BufferSlice *getHead() const {
         return (BufferSlice *)this->head;
     }
@@ -418,18 +418,18 @@ struct AssemblerBufferWithConstantPools 
           instBufferAlign_(instBufferAlign),
           numDumps_(0), poolInfoSize_(8), poolInfo_(nullptr),
           canNotPlacePool_(false), alignFillInst_(alignFillInst),
           nopFillInst_(nopFillInst), nopFill_(nopFill), inhibitNops_(false),
           id(-1)
     {
     }
 
-    // We need to wait until an AutoIonContextAlloc is created by the
-    // IonMacroAssembler before allocating any space.
+    // We need to wait until an AutoJitContextAlloc is created by the
+    // MacroAssembler before allocating any space.
     void initWithAllocator() {
         poolInfo_ = this->lifoAlloc_.template newArrayUninitialized<PoolInfo>(poolInfoSize_);
 
         new (&pool_) Pool (poolMaxOffset_, pcBias_, this->lifoAlloc_);
         if (pool_.poolData() == nullptr)
             this->fail_oom();
     }
 
--- a/js/src/jit/shared/MacroAssembler-x86-shared.cpp
+++ b/js/src/jit/shared/MacroAssembler-x86-shared.cpp
@@ -1,18 +1,18 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/shared/MacroAssembler-x86-shared.h"
 
-#include "jit/IonFrames.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/JitFrames.h"
+#include "jit/MacroAssembler.h"
 
 using namespace js;
 using namespace js::jit;
 
 void
 MacroAssembler::PushRegsInMask(RegisterSet set, FloatRegisterSet simdSet)
 {
     FloatRegisterSet doubleSet(FloatRegisterSet::Subtract(set.fpus(), simdSet));
@@ -156,17 +156,17 @@ MacroAssemblerX86Shared::buildFakeExitFr
 
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor));
     Push(scratch);
 
     bind(cl.src());
     *offset = currentOffset();
 
-    MOZ_ASSERT(framePushed() == initialDepth + IonExitFrameLayout::Size());
+    MOZ_ASSERT(framePushed() == initialDepth + ExitFrameLayout::Size());
     return addCodeLabel(cl);
 }
 
 void
 MacroAssemblerX86Shared::callWithExitFrame(Label *target)
 {
     uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
     Push(Imm32(descriptor));
--- a/js/src/jit/shared/MacroAssembler-x86-shared.h
+++ b/js/src/jit/shared/MacroAssembler-x86-shared.h
@@ -1197,17 +1197,17 @@ class MacroAssemblerX86Shared : public A
     void call(const CallSiteDesc &desc, Label *label) {
         call(label);
         append(desc, currentOffset(), framePushed_);
     }
     void call(const CallSiteDesc &desc, Register reg) {
         call(reg);
         append(desc, currentOffset(), framePushed_);
     }
-    void callIon(Register callee) {
+    void callJit(Register callee) {
         call(callee);
     }
     void callJitFromAsmJS(Register callee) {
         call(callee);
     }
     void call(AsmJSImmPtr target) {
         mov(target, eax);
         call(eax);
--- a/js/src/jit/x64/Bailouts-x64.cpp
+++ b/js/src/jit/x64/Bailouts-x64.cpp
@@ -48,17 +48,17 @@ class BailoutStack
 BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator &activations,
                                    BailoutStack *bailout)
   : machine_(bailout->machineState())
 {
     uint8_t *sp = bailout->parentStackPointer();
     framePointer_ = sp + bailout->frameSize();
     topFrameSize_ = framePointer_ - sp;
 
-    JSScript *script = ScriptFromCalleeToken(((IonJSFrameLayout *) framePointer_)->calleeToken());
+    JSScript *script = ScriptFromCalleeToken(((JitFrameLayout *) framePointer_)->calleeToken());
     JitActivation *activation = activations.activation()->asJit();
     if (activation->cx()->isForkJoinContext())
         topIonScript_ = script->parallelIonScript();
     else
         topIonScript_ = script->ionScript();
 
     attachOnJitActivation(activations);
     snapshotOffset_ = bailout->snapshotOffset();
--- a/js/src/jit/x64/BaselineHelpers-x64.h
+++ b/js/src/jit/x64/BaselineHelpers-x64.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_BaselineHelpers_x64_h
 #define jit_x64_BaselineHelpers_x64_h
 
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 // Distance from Stack top to the top Value inside an IC stub (this is the return address).
 static const size_t ICStackValueOffset = sizeof(void *);
 
 inline void
--- a/js/src/jit/x64/BaselineRegisters-x64.h
+++ b/js/src/jit/x64/BaselineRegisters-x64.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_BaselineRegisters_x64_h
 #define jit_x64_BaselineRegisters_x64_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg    = rbp;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg    = rsp;
 
 static MOZ_CONSTEXPR_VAR ValueOperand R0(rcx);
--- a/js/src/jit/x64/MacroAssembler-x64.cpp
+++ b/js/src/jit/x64/MacroAssembler-x64.cpp
@@ -3,18 +3,18 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/x64/MacroAssembler-x64.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
-#include "jit/IonFrames.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/MoveEmitter.h"
 
 using namespace js;
 using namespace js::jit;
 
 void
 MacroAssemblerX64::loadConstantDouble(double d, FloatRegister dest)
 {
@@ -384,17 +384,17 @@ MacroAssemblerX64::handleFailureWithHand
     subq(Imm32(sizeof(ResumeFromException)), rsp);
     movq(rsp, rax);
 
     // Ask for an exception handler.
     setupUnalignedABICall(1, rcx);
     passABIArg(rax);
     callWithABI(handler);
 
-    JitCode *excTail = GetIonContext()->runtime->jitRuntime()->getExceptionTail();
+    JitCode *excTail = GetJitContext()->runtime->jitRuntime()->getExceptionTail();
     jmp(excTail);
 }
 
 void
 MacroAssemblerX64::handleFailureWithHandlerTail()
 {
     Label entryFrame;
     Label catch_;
@@ -501,31 +501,31 @@ MacroAssemblerX64::storeUnboxedValue(Con
 
 void
 MacroAssemblerX64::branchPtrInNurseryRange(Condition cond, Register ptr, Register temp, Label *label)
 {
     MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
     MOZ_ASSERT(ptr != temp);
     MOZ_ASSERT(ptr != ScratchReg);
 
-    const Nursery &nursery = GetIonContext()->runtime->gcNursery();
+    const Nursery &nursery = GetJitContext()->runtime->gcNursery();
     movePtr(ImmWord(-ptrdiff_t(nursery.start())), ScratchReg);
     addPtr(ptr, ScratchReg);
     branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
               ScratchReg, Imm32(nursery.nurserySize()), label);
 }
 
 void
 MacroAssemblerX64::branchValueIsNurseryObject(Condition cond, ValueOperand value, Register temp,
                                               Label *label)
 {
     MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
 
     // 'Value' representing the start of the nursery tagged as a JSObject
-    const Nursery &nursery = GetIonContext()->runtime->gcNursery();
+    const Nursery &nursery = GetJitContext()->runtime->gcNursery();
     Value start = ObjectValue(*reinterpret_cast<JSObject *>(nursery.start()));
 
     movePtr(ImmWord(-ptrdiff_t(start.asRawBits())), ScratchReg);
     addPtr(value.valueReg(), ScratchReg);
     branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
               ScratchReg, Imm32(nursery.nurserySize()), label);
 }
 
--- a/js/src/jit/x64/MacroAssembler-x64.h
+++ b/js/src/jit/x64/MacroAssembler-x64.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_MacroAssembler_x64_h
 #define jit_x64_MacroAssembler_x64_h
 
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/MoveResolver.h"
 #include "jit/shared/MacroAssembler-x86-shared.h"
 
 namespace js {
 namespace jit {
 
 struct ImmShiftedTag : public ImmWord
 {
--- a/js/src/jit/x64/Trampoline-x64.cpp
+++ b/js/src/jit/x64/Trampoline-x64.cpp
@@ -1,18 +1,18 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/Bailouts.h"
-#include "jit/IonFrames.h"
-#include "jit/IonLinker.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
+#include "jit/Linker.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/ParallelFunctions.h"
 #include "jit/VMFunctions.h"
 #include "jit/x64/BaselineHelpers-x64.h"
 
 using namespace js;
@@ -204,17 +204,17 @@ JitRuntime::generateEnterJIT(JSContext *
         masm.subPtr(valuesSize, rsp);
 
         // Enter exit frame.
         masm.addPtr(Imm32(BaselineFrame::Size() + BaselineFrame::FramePointerOffset), valuesSize);
         masm.makeFrameDescriptor(valuesSize, JitFrame_BaselineJS);
         masm.push(valuesSize);
         masm.push(Imm32(0)); // Fake return address.
         // No GC things to mark, push a bare token.
-        masm.enterFakeExitFrame(IonExitFrameLayout::BareToken());
+        masm.enterFakeExitFrame(ExitFrameLayout::BareToken());
 
         regs.add(valuesSize);
 
         masm.push(framePtr);
         masm.push(reg_code);
 
         masm.setupUnalignedABICall(3, scratch);
         masm.passABIArg(framePtr); // BaselineFrame
@@ -223,17 +223,17 @@ JitRuntime::generateEnterJIT(JSContext *
         masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, jit::InitBaselineFrameForOsr));
 
         masm.pop(reg_code);
         masm.pop(framePtr);
 
         MOZ_ASSERT(reg_code != ReturnReg);
 
         Label error;
-        masm.addPtr(Imm32(IonExitFrameLayout::SizeWithFooter()), rsp);
+        masm.addPtr(Imm32(ExitFrameLayout::SizeWithFooter()), rsp);
         masm.addPtr(Imm32(BaselineFrame::Size()), framePtr);
         masm.branchIfFalseBool(ReturnReg, &error);
 
         masm.jump(reg_code);
 
         // OOM: load error value, discard return address and previous frame
         // pointer and return.
         masm.bind(&error);
@@ -307,17 +307,17 @@ JitRuntime::generateEnterJIT(JSContext *
 #endif
 
     return code;
 }
 
 JitCode *
 JitRuntime::generateInvalidator(JSContext *cx)
 {
-    AutoIonContextAlloc aica(cx);
+    AutoJitContextAlloc ajca(cx);
     MacroAssembler masm(cx);
 
     // See explanatory comment in x86's JitRuntime::generateInvalidator.
 
     masm.addq(Imm32(sizeof(uintptr_t)), rsp);
 
     // Push registers such that we can access them from [base + code].
     masm.PushRegsInMask(AllRegs);
@@ -365,41 +365,41 @@ JitRuntime::generateArgumentsRectifier(J
 
     MacroAssembler masm(cx);
 
     // ArgumentsRectifierReg contains the |nargs| pushed onto the current frame.
     // Including |this|, there are (|nargs| + 1) arguments to copy.
     MOZ_ASSERT(ArgumentsRectifierReg == r8);
 
     // Load the number of |undefined|s to push into %rcx.
-    masm.loadPtr(Address(rsp, IonRectifierFrameLayout::offsetOfCalleeToken()), rax);
+    masm.loadPtr(Address(rsp, RectifierFrameLayout::offsetOfCalleeToken()), rax);
     masm.mov(rax, rcx);
     masm.andq(Imm32(uint32_t(CalleeTokenMask)), rcx);
     masm.movzwl(Operand(rcx, JSFunction::offsetOfNargs()), rcx);
     masm.subq(r8, rcx);
 
     // Copy the number of actual arguments
-    masm.loadPtr(Address(rsp, IonRectifierFrameLayout::offsetOfNumActualArgs()), rdx);
+    masm.loadPtr(Address(rsp, RectifierFrameLayout::offsetOfNumActualArgs()), rdx);
 
     masm.moveValue(UndefinedValue(), r10);
 
     masm.movq(rsp, r9); // Save %rsp.
 
     // Push undefined.
     {
         Label undefLoopTop;
         masm.bind(&undefLoopTop);
 
         masm.push(r10);
         masm.subl(Imm32(1), rcx);
         masm.j(Assembler::NonZero, &undefLoopTop);
     }
 
     // Get the topmost argument.
-    BaseIndex b = BaseIndex(r9, r8, TimesEight, sizeof(IonRectifierFrameLayout));
+    BaseIndex b = BaseIndex(r9, r8, TimesEight, sizeof(RectifierFrameLayout));
     masm.lea(Operand(b), rcx);
 
     // Push arguments, |nargs| + 1 times (to include |this|).
     masm.addl(Imm32(1), r8);
     {
         Label copyLoopTop;
 
         masm.bind(&copyLoopTop);
@@ -408,17 +408,17 @@ JitRuntime::generateArgumentsRectifier(J
         masm.subl(Imm32(1), r8);
         masm.j(Assembler::NonZero, &copyLoopTop);
     }
 
     // Construct descriptor.
     masm.subq(rsp, r9);
     masm.makeFrameDescriptor(r9, JitFrame_Rectifier);
 
-    // Construct IonJSFrameLayout.
+    // Construct JitFrameLayout.
     masm.push(rdx); // numActualArgs
     masm.push(rax); // callee token
     masm.push(r9); // descriptor
 
     // Call the target function.
     // Note that this code assumes the function is JITted.
     masm.andq(Imm32(uint32_t(CalleeTokenMask)), rax);
     masm.loadPtr(Address(rax, JSFunction::offsetOfNativeOrScript()), rax);
@@ -583,17 +583,17 @@ JitRuntime::generateVMWrapper(JSContext 
     // We're aligned to an exit frame, so link it up.
     masm.enterExitFrameAndLoadContext(&f, cxreg, regs.getAny(), f.executionMode);
 
     // Save the current stack pointer as the base for copying arguments.
     Register argsBase = InvalidReg;
     if (f.explicitArgs) {
         argsBase = r10;
         regs.take(argsBase);
-        masm.lea(Operand(rsp,IonExitFrameLayout::SizeWithFooter()), argsBase);
+        masm.lea(Operand(rsp, ExitFrameLayout::SizeWithFooter()), argsBase);
     }
 
     // Reserve space for the outparameter.
     Register outReg = InvalidReg;
     switch (f.outParam) {
       case Type_Value:
         outReg = regs.takeAny();
         masm.reserveStack(sizeof(Value));
@@ -708,17 +708,17 @@ JitRuntime::generateVMWrapper(JSContext 
         masm.freeStack(sizeof(uintptr_t));
         break;
 
       default:
         MOZ_ASSERT(f.outParam == Type_Void);
         break;
     }
     masm.leaveExitFrame();
-    masm.retn(Imm32(sizeof(IonExitFrameLayout) +
+    masm.retn(Imm32(sizeof(ExitFrameLayout) +
                     f.explicitStackSlots() * sizeof(void *) +
                     f.extraValuesToPop * sizeof(Value)));
 
     Linker linker(masm);
     JitCode *wrapper = linker.newCode<NoGC>(cx, OTHER_CODE);
     if (!wrapper)
         return nullptr;
 
--- a/js/src/jit/x86/Bailouts-x86.cpp
+++ b/js/src/jit/x86/Bailouts-x86.cpp
@@ -68,17 +68,17 @@ class BailoutStack
 BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator &activations,
                                    BailoutStack *bailout)
   : machine_(bailout->machine())
 {
     uint8_t *sp = bailout->parentStackPointer();
     framePointer_ = sp + bailout->frameSize();
     topFrameSize_ = framePointer_ - sp;
 
-    JSScript *script = ScriptFromCalleeToken(((IonJSFrameLayout *) framePointer_)->calleeToken());
+    JSScript *script = ScriptFromCalleeToken(((JitFrameLayout *) framePointer_)->calleeToken());
     JitActivation *activation = activations.activation()->asJit();
     if (activation->cx()->isForkJoinContext())
         topIonScript_ = script->parallelIonScript();
     else
         topIonScript_ = script->ionScript();
 
     attachOnJitActivation(activations);
 
--- a/js/src/jit/x86/BaselineHelpers-x86.h
+++ b/js/src/jit/x86/BaselineHelpers-x86.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_BaselineHelpers_x86_h
 #define jit_x86_BaselineHelpers_x86_h
 
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 // Distance from stack top to the top Value inside an IC stub (this is the return address).
 static const size_t ICStackValueOffset = sizeof(void *);
 
 inline void
--- a/js/src/jit/x86/BaselineIC-x86.cpp
+++ b/js/src/jit/x86/BaselineIC-x86.cpp
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
-#include "jit/IonLinker.h"
+#include "jit/Linker.h"
 
 using namespace js;
 using namespace js::jit;
 
 namespace js {
 namespace jit {
 
 // ICCompare_Int32
--- a/js/src/jit/x86/BaselineRegisters-x86.h
+++ b/js/src/jit/x86/BaselineRegisters-x86.h
@@ -2,17 +2,17 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_BaselineRegisters_x86_h
 #define jit_x86_BaselineRegisters_x86_h
 
-#include "jit/IonMacroAssembler.h"
+#include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = ebp;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = esp;
 
 // ValueOperands R0, R1, and R2
--- a/js/src/jit/x86/MacroAssembler-x86.cpp
+++ b/js/src/jit/x86/MacroAssembler-x86.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/x86/MacroAssembler-x86.h"
 
 #include "mozilla/Casting.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/MoveEmitter.h"
 
 #include "jsscriptinlines.h"
 
 using namespace js;
 using namespace js::jit;
 
 MacroAssemblerX86::Double *
@@ -364,17 +364,17 @@ MacroAssemblerX86::handleFailureWithHand
     subl(Imm32(sizeof(ResumeFromException)), esp);
     movl(esp, eax);
 
     // Ask for an exception handler.
     setupUnalignedABICall(1, ecx);
     passABIArg(eax);
     callWithABI(handler);
 
-    JitCode *excTail = GetIonContext()->runtime->jitRuntime()->getExceptionTail();
+    JitCode *excTail = GetJitContext()->runtime->jitRuntime()->getExceptionTail();
     jmp(excTail);
 }
 
 void
 MacroAssemblerX86::handleFailureWithHandlerTail()
 {
     Label entryFrame;
     Label catch_;
@@ -498,17 +498,17 @@ MacroAssemblerX86::storeUnboxedValue(Con
 void
 MacroAssemblerX86::branchPtrInNurseryRange(Condition cond, Register ptr, Register temp,
                                            Label *label)
 {
     MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
     MOZ_ASSERT(ptr != temp);
     MOZ_ASSERT(temp != InvalidReg);  // A temp register is required for x86.
 
-    const Nursery &nursery = GetIonContext()->runtime->gcNursery();
+    const Nursery &nursery = GetJitContext()->runtime->gcNursery();
     movePtr(ImmWord(-ptrdiff_t(nursery.start())), temp);
     addPtr(ptr, temp);
     branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
               temp, Imm32(nursery.nurserySize()), label);
 }
 
 void
 MacroAssemblerX86::branchValueIsNurseryObject(Condition cond, ValueOperand value, Register temp,
--- a/js/src/jit/x86/MacroAssembler-x86.h
+++ b/js/src/jit/x86/MacroAssembler-x86.h
@@ -4,17 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_MacroAssembler_x86_h
 #define jit_x86_MacroAssembler_x86_h
 
 #include "jscompartment.h"
 
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "jit/MoveResolver.h"
 #include "jit/shared/MacroAssembler-x86-shared.h"
 
 namespace js {
 namespace jit {
 
 class MacroAssemblerX86 : public MacroAssemblerX86Shared
 {
--- a/js/src/jit/x86/Trampoline-x86.cpp
+++ b/js/src/jit/x86/Trampoline-x86.cpp
@@ -3,20 +3,20 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jscompartment.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineJIT.h"
-#include "jit/IonFrames.h"
-#include "jit/IonLinker.h"
 #include "jit/JitCompartment.h"
+#include "jit/JitFrames.h"
 #include "jit/JitSpewer.h"
+#include "jit/Linker.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/ParallelFunctions.h"
 #include "jit/VMFunctions.h"
 #include "jit/x86/BaselineHelpers-x86.h"
 
 #include "jsscriptinlines.h"
@@ -199,34 +199,34 @@ JitRuntime::generateEnterJIT(JSContext *
         masm.subPtr(scratch, esp);
 
         // Enter exit frame.
         masm.addPtr(Imm32(BaselineFrame::Size() + BaselineFrame::FramePointerOffset), scratch);
         masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
         masm.push(scratch); // Fake return address.
         masm.push(Imm32(0));
         // No GC things to mark on the stack, push a bare token.
-        masm.enterFakeExitFrame(IonExitFrameLayout::BareToken());
+        masm.enterFakeExitFrame(ExitFrameLayout::BareToken());
 
         masm.push(framePtr);
         masm.push(jitcode);
 
         masm.setupUnalignedABICall(3, scratch);
         masm.passABIArg(framePtr); // BaselineFrame
         masm.passABIArg(OsrFrameReg); // InterpreterFrame
         masm.passABIArg(numStackValues);
         masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, jit::InitBaselineFrameForOsr));
 
         masm.pop(jitcode);
         masm.pop(framePtr);
 
         MOZ_ASSERT(jitcode != ReturnReg);
 
         Label error;
-        masm.addPtr(Imm32(IonExitFrameLayout::SizeWithFooter()), esp);
+        masm.addPtr(Imm32(ExitFrameLayout::SizeWithFooter()), esp);
         masm.addPtr(Imm32(BaselineFrame::Size()), framePtr);
         masm.branchIfFalseBool(ReturnReg, &error);
 
         masm.jump(jitcode);
 
         // OOM: load error value, discard return address and previous frame
         // pointer and return.
         masm.bind(&error);
@@ -294,17 +294,17 @@ JitRuntime::generateEnterJIT(JSContext *
 #endif
 
     return code;
 }
 
 JitCode *
 JitRuntime::generateInvalidator(JSContext *cx)
 {
-    AutoIonContextAlloc aica(cx);
+    AutoJitContextAlloc ajca(cx);
     MacroAssembler masm(cx);
 
     // We do the minimum amount of work in assembly and shunt the rest
     // off to InvalidationBailout. Assembly does:
     //
     // - Pop the return address from the invalidation epilogue call.
     // - Push the machine state onto the stack.
     // - Call the InvalidationBailout routine with the stack pointer.
@@ -359,24 +359,24 @@ JitRuntime::generateArgumentsRectifier(J
 {
     MacroAssembler masm(cx);
 
     // ArgumentsRectifierReg contains the |nargs| pushed onto the current frame.
     // Including |this|, there are (|nargs| + 1) arguments to copy.
     MOZ_ASSERT(ArgumentsRectifierReg == esi);
 
     // Load the number of |undefined|s to push into %ecx.
-    masm.loadPtr(Address(esp, IonRectifierFrameLayout::offsetOfCalleeToken()), eax);
+    masm.loadPtr(Address(esp, RectifierFrameLayout::offsetOfCalleeToken()), eax);
     masm.mov(eax, ecx);
     masm.andl(Imm32(CalleeTokenMask), ecx);
     masm.movzwl(Operand(ecx, JSFunction::offsetOfNargs()), ecx);
     masm.subl(esi, ecx);
 
     // Copy the number of actual arguments.
-    masm.loadPtr(Address(esp, IonRectifierFrameLayout::offsetOfNumActualArgs()), edx);
+    masm.loadPtr(Address(esp, RectifierFrameLayout::offsetOfNumActualArgs()), edx);
 
     masm.moveValue(UndefinedValue(), ebx, edi);
 
     // NOTE: The fact that x86 ArgumentsRectifier saves the FramePointer is relied upon
     // by the baseline bailout code.  If this changes, fix that code!  See
     // BaselineJIT.cpp/BaselineStackBuilder::calculatePrevFramePtr, and
     // BaselineJIT.cpp/InitFromBailout.  Check for the |#if defined(JS_CODEGEN_X86)| portions.
     masm.push(FramePointer);
@@ -391,17 +391,17 @@ JitRuntime::generateArgumentsRectifier(J
         masm.push(edi); // payload(undefined);
         masm.subl(Imm32(1), ecx);
         masm.j(Assembler::NonZero, &undefLoopTop);
     }
 
     // Get the topmost argument. We did a push of %ebp earlier, so be sure to
     // account for this in the offset
     BaseIndex b = BaseIndex(FramePointer, esi, TimesEight,
-                            sizeof(IonRectifierFrameLayout) + sizeof(void*));
+                            sizeof(RectifierFrameLayout) + sizeof(void*));
     masm.lea(Operand(b), ecx);
 
     // Push arguments, |nargs| + 1 times (to include |this|).
     masm.addl(Imm32(1), esi);
     {
         Label copyLoopTop;
 
         masm.bind(&copyLoopTop);
@@ -412,17 +412,17 @@ JitRuntime::generateArgumentsRectifier(J
         masm.j(Assembler::NonZero, &copyLoopTop);
     }
 
     // Construct descriptor, accounting for pushed frame pointer above
     masm.lea(Operand(FramePointer, sizeof(void*)), ebx);
     masm.subl(esp, ebx);
     masm.makeFrameDescriptor(ebx, JitFrame_Rectifier);
 
-    // Construct IonJSFrameLayout.
+    // Construct JitFrameLayout.
     masm.push(edx); // number of actual arguments
     masm.push(eax); // callee token
     masm.push(ebx); // descriptor
 
     // Call the target function.
     // Note that this assumes the function is JITted.
     masm.andl(Imm32(CalleeTokenMask), eax);
     masm.loadPtr(Address(eax, JSFunction::offsetOfNativeOrScript()), eax);
@@ -620,17 +620,17 @@ JitRuntime::generateVMWrapper(JSContext 
     //
     // We're aligned to an exit frame, so link it up.
     masm.enterExitFrameAndLoadContext(&f, cxreg, regs.getAny(), f.executionMode);
 
     // Save the current stack pointer as the base for copying arguments.
     Register argsBase = InvalidReg;
     if (f.explicitArgs) {
         argsBase = regs.takeAny();
-        masm.lea(Operand(esp, IonExitFrameLayout::SizeWithFooter()), argsBase);
+        masm.lea(Operand(esp, ExitFrameLayout::SizeWithFooter()), argsBase);
     }
 
     // Reserve space for the outparameter.
     Register outReg = InvalidReg;
     switch (f.outParam) {
       case Type_Value:
         outReg = regs.takeAny();
         masm.Push(UndefinedValue());
@@ -742,17 +742,17 @@ JitRuntime::generateVMWrapper(JSContext 
             masm.assumeUnreachable("Unable to pop to float reg, with no FP support.");
         break;
 
       default:
         MOZ_ASSERT(f.outParam == Type_Void);
         break;
     }
     masm.leaveExitFrame();
-    masm.retn(Imm32(sizeof(IonExitFrameLayout) +
+    masm.retn(Imm32(sizeof(ExitFrameLayout) +
                     f.explicitStackSlots() * sizeof(void *) +
                     f.extraValuesToPop * sizeof(Value)));
 
     Linker linker(masm);
     JitCode *wrapper = linker.newCode<NoGC>(cx, OTHER_CODE);
     if (!wrapper)
         return nullptr;
 
--- a/js/src/jsapi-tests/testJitMoveEmitterCycles-mips.cpp
+++ b/js/src/jsapi-tests/testJitMoveEmitterCycles-mips.cpp
@@ -1,18 +1,18 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #if defined(JS_MIPS_SIMULATOR)
-#include "jit/IonLinker.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/Linker.h"
+#include "jit/MacroAssembler.h"
 #include "jit/mips/Assembler-mips.h"
 #include "jit/mips/MoveEmitter-mips.h"
 #include "jit/mips/Simulator-mips.h"
 #include "jit/MoveResolver.h"
 
 #include "jsapi-tests/tests.h"
 
 #include "vm/Runtime.h"
@@ -78,17 +78,17 @@ linkAndAllocate(JSContext *cx, MacroAsse
 }
 
 BEGIN_TEST(testJitMoveEmitterCycles_simple)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     AutoFlushICache afc("test");
 
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
@@ -121,17 +121,17 @@ BEGIN_TEST(testJitMoveEmitterCycles_simp
 }
 END_TEST(testJitMoveEmitterCycles_simple)
 BEGIN_TEST(testJitMoveEmitterCycles_autogen)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     AutoFlushICache afc("test");
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     sim->setFpuRegisterDouble(double9.id(), 9.0);
@@ -209,17 +209,17 @@ BEGIN_TEST(testJitMoveEmitterCycles_auto
 END_TEST(testJitMoveEmitterCycles_autogen)
 
 BEGIN_TEST(testJitMoveEmitterCycles_autogen2)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     AutoFlushICache afc("test");
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     mr.addMove(MoveOperand(double10), MoveOperand(double0), MoveOp::DOUBLE);
@@ -309,17 +309,17 @@ END_TEST(testJitMoveEmitterCycles_autoge
 
 
 BEGIN_TEST(testJitMoveEmitterCycles_autogen3)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     AutoFlushICache afc("test");
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     mr.addMove(MoveOperand(single0), MoveOperand(single21), MoveOp::FLOAT32);
--- a/js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
+++ b/js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
@@ -4,18 +4,18 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #if defined(JS_ARM_SIMULATOR)
 #include "jit/arm/Assembler-arm.h"
 #include "jit/arm/MoveEmitter-arm.h"
 #include "jit/arm/Simulator-arm.h"
-#include "jit/IonLinker.h"
-#include "jit/IonMacroAssembler.h"
+#include "jit/Linker.h"
+#include "jit/MacroAssembler.h"
 #include "jit/MoveResolver.h"
 
 #include "jsapi-tests/tests.h"
 
 #include "vm/Runtime.h"
 
 static const int LIFO_ALLOC_PRIMARY_CHUNK_SIZE = 4*1024;
 
@@ -63,17 +63,17 @@ linkAndAllocate(JSContext *cx, js::jit::
 }
 
 BEGIN_TEST(testJitMoveEmitterCycles_simple)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     mr.addMove(MoveOperand(d0), MoveOperand(d2), MoveOp::DOUBLE);
     sim->set_d_register_from_double(0, 2);
@@ -104,17 +104,17 @@ BEGIN_TEST(testJitMoveEmitterCycles_simp
 }
 END_TEST(testJitMoveEmitterCycles_simple)
 BEGIN_TEST(testJitMoveEmitterCycles_autogen)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     mr.addMove(MoveOperand(d9), MoveOperand(d14), MoveOp::DOUBLE);
     sim->set_d_register_from_double(9, 9);
@@ -204,17 +204,17 @@ BEGIN_TEST(testJitMoveEmitterCycles_auto
 END_TEST(testJitMoveEmitterCycles_autogen)
 
 BEGIN_TEST(testJitMoveEmitterCycles_autogen2)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     mr.addMove(MoveOperand(d10), MoveOperand(d0), MoveOp::DOUBLE);
     sim->set_d_register_from_double(10, 10);
@@ -317,17 +317,17 @@ END_TEST(testJitMoveEmitterCycles_autoge
 
 
 BEGIN_TEST(testJitMoveEmitterCycles_autogen3)
 {
     using namespace js;
     using namespace js::jit;
     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
     TempAllocator alloc(&lifo);
-    IonContext ic(cx, &alloc);
+    JitContext jc(cx, &alloc);
     rt->getJitRuntime(cx);
     MacroAssembler masm;
     MoveEmitter mover(masm);
     MoveResolver mr;
     mr.setAllocator(alloc);
     Simulator *sim = Simulator::Current();
     mr.addMove(MoveOperand(s0), MoveOperand(s21), MoveOp::FLOAT32);
     sim->set_s_register_from_float(0, 0);
--- a/js/src/jscntxt.h
+++ b/js/src/jscntxt.h
@@ -28,17 +28,17 @@ extern void
 js_ReportAllocationOverflow(js::ThreadSafeContext *cx);
 
 extern void
 js_ReportOverRecursed(js::ThreadSafeContext *cx);
 
 namespace js {
 
 namespace jit {
-class IonContext;
+class JitContext;
 class CompileCompartment;
 class DebugModeOSRVolatileJitFrameIterator;
 }
 
 struct CallsiteCloneKey {
     /* The original function that we are cloning. */
     JSFunction *original;
 
@@ -308,17 +308,17 @@ struct HelperThread;
 
 class ExclusiveContext : public ThreadSafeContext
 {
     friend class gc::ArenaLists;
     friend class AutoCompartment;
     friend class AutoLockForExclusiveAccess;
     friend struct StackBaseShape;
     friend void JSScript::initCompartment(ExclusiveContext *cx);
-    friend class jit::IonContext;
+    friend class jit::JitContext;
 
     // The thread on which this context is running, if this is not a JSContext.
     HelperThread *helperThread_;
 
   public:
 
     ExclusiveContext(JSRuntime *rt, PerThreadData *pt, ContextKind kind)
       : ThreadSafeContext(rt, pt, kind),
--- a/js/src/jscntxtinlines.h
+++ b/js/src/jscntxtinlines.h
@@ -8,17 +8,17 @@
 #define jscntxtinlines_h
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jsiter.h"
 
 #include "builtin/Object.h"
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "vm/ForkJoin.h"
 #include "vm/HelperThreads.h"
 #include "vm/Interpreter.h"
 #include "vm/ProxyObject.h"
 #include "vm/Symbol.h"
 
 #include "gc/ForkJoinNursery-inl.h"
 
--- a/js/src/jsfun.h
+++ b/js/src/jsfun.h
@@ -145,17 +145,17 @@ class JSFunction : public js::NativeObje
     bool isArrow()                  const { return flags() & ARROW; }
 
     /* Compound attributes: */
     bool isBuiltin() const {
         return (isNative() && !isAsmJSNative()) || isSelfHostedBuiltin();
     }
     bool isInterpretedConstructor() const {
         // Note: the JITs inline this check, so be careful when making changes
-        // here. See IonMacroAssembler::branchIfNotInterpretedConstructor.
+        // here. See MacroAssembler::branchIfNotInterpretedConstructor.
         return isInterpreted() && !isFunctionPrototype() && !isArrow() &&
                (!isSelfHostedBuiltin() || isSelfHostedConstructor());
     }
     bool isNamedLambda() const {
         return isLambda() && displayAtom() && !hasGuessedAtom();
     }
     bool hasParallelNative() const {
         return isNative() && jitInfo() && jitInfo()->hasParallelNative();
--- a/js/src/jsinfer.cpp
+++ b/js/src/jsinfer.cpp
@@ -822,17 +822,17 @@ TypeSet::intersectSets(TemporaryTypeSet 
 //
 // At the end of compilation, when linking the result on the main thread, the
 // list of compiler constraints are read and converted to type constraints and
 // attached to the type sets. If the property type sets have changed so that the
 // assumptions no longer hold then the compilation is aborted and its result
 // discarded.
 
 // Superclass of all constraints generated during Ion compilation. These may
-// be allocated off the main thread, using the current Ion context's allocator.
+// be allocated off the main thread, using the current JIT context's allocator.
 class CompilerConstraint
 {
   public:
     // Property being queried by the compiler.
     HeapTypeSetKey property;
 
     // Contents of the property at the point when the query was performed. This
     // may differ from the actual property types later in compilation as the
@@ -864,20 +864,20 @@ class types::CompilerConstraintList
 
     // OOM during generation of some constraint.
     bool failed_;
 
     // Allocator used for constraints.
     LifoAlloc *alloc_;
 
     // Constraints generated on heap properties.
-    Vector<CompilerConstraint *, 0, jit::IonAllocPolicy> constraints;
+    Vector<CompilerConstraint *, 0, jit::JitAllocPolicy> constraints;
 
     // Scripts whose stack type sets were frozen for the compilation.
-    Vector<FrozenScript, 1, jit::IonAllocPolicy> frozenScripts;
+    Vector<FrozenScript, 1, jit::JitAllocPolicy> frozenScripts;
 
   public:
     explicit CompilerConstraintList(jit::TempAllocator &alloc)
       : failed_(false),
         alloc_(alloc.lifoAlloc()),
         constraints(alloc),
         frozenScripts(alloc)
     {}
--- a/js/src/jsinfer.h
+++ b/js/src/jsinfer.h
@@ -199,17 +199,17 @@ template <> struct ExecutionModeTraits<P
     typedef ForkJoinContext * ContextType;
     typedef ForkJoinContext * ExclusiveContextType;
 
     static inline ForkJoinContext *toContextType(ForkJoinContext *cx) { return cx; }
 };
 
 namespace jit {
     struct IonScript;
-    class IonAllocPolicy;
+    class JitAllocPolicy;
     class TempAllocator;
 }
 
 namespace types {
 
 struct TypeZone;
 class TypeSet;
 struct TypeObjectKey;
--- a/js/src/jsscript.cpp
+++ b/js/src/jsscript.cpp
@@ -2707,17 +2707,17 @@ JSScript::finalize(FreeOp *fop)
     // JSScript::Create(), but not yet finished initializing it with
     // fullyInitFromEmitter() or fullyInitTrivial().
 
     fop->runtime()->spsProfiler.onScriptFinalized(this);
 
     if (types_)
         types_->destroy();
 
-    jit::DestroyIonScripts(fop, this);
+    jit::DestroyJitScripts(fop, this);
 
     destroyScriptCounts(fop);
     destroyDebugScript(fop);
 
     if (data) {
         JS_POISON(data, 0xdb, computedSizeOfData());
         fop->free_(data);
     }
@@ -3427,17 +3427,17 @@ JSScript::markChildren(JSTracer *trc)
         compartment()->mark();
 
         if (code())
             MarkScriptData(trc->runtime(), code());
     }
 
     bindings.trace(trc);
 
-    jit::TraceIonScripts(trc, this);
+    jit::TraceJitScripts(trc, this);
 }
 
 void
 LazyScript::markChildren(JSTracer *trc)
 {
     if (function_)
         MarkObject(trc, &function_, "function");
 
--- a/js/src/moz.build
+++ b/js/src/moz.build
@@ -156,29 +156,29 @@ UNIFIED_SOURCES += [
     'jit/CompileWrappers.cpp',
     'jit/EdgeCaseAnalysis.cpp',
     'jit/EffectiveAddressAnalysis.cpp',
     'jit/ExecutableAllocator.cpp',
     'jit/Ion.cpp',
     'jit/IonAnalysis.cpp',
     'jit/IonBuilder.cpp',
     'jit/IonCaches.cpp',
-    'jit/IonFrames.cpp',
-    'jit/IonMacroAssembler.cpp',
     'jit/IonOptimizationLevels.cpp',
     'jit/JitcodeMap.cpp',
+    'jit/JitFrames.cpp',
     'jit/JitOptions.cpp',
     'jit/JitSpewer.cpp',
     'jit/JSONSpewer.cpp',
     'jit/LICM.cpp',
     'jit/LinearScan.cpp',
     'jit/LIR.cpp',
     'jit/LiveRangeAllocator.cpp',
     'jit/LoopUnroller.cpp',
     'jit/Lowering.cpp',
+    'jit/MacroAssembler.cpp',
     'jit/MCallOptimize.cpp',
     'jit/MIR.cpp',
     'jit/MIRGraph.cpp',
     'jit/MoveResolver.cpp',
     'jit/ParallelFunctions.cpp',
     'jit/ParallelSafetyAnalysis.cpp',
     'jit/PerfSpewer.cpp',
     'jit/RangeAnalysis.cpp',
--- a/js/src/vm/ArgumentsObject.cpp
+++ b/js/src/vm/ArgumentsObject.cpp
@@ -3,17 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "vm/ArgumentsObject-inl.h"
 
 #include "jsinfer.h"
 
-#include "jit/IonFrames.h"
+#include "jit/JitFrames.h"
 #include "vm/GlobalObject.h"
 #include "vm/Stack.h"
 
 #include "jsobjinlines.h"
 
 #include "vm/Stack-inl.h"
 
 using namespace js;
@@ -41,17 +41,17 @@ ArgumentsObject::MaybeForwardToCallObjec
     if (frame.fun()->isHeavyweight() && script->argsObjAliasesFormals()) {
         obj->initFixedSlot(MAYBE_CALL_SLOT, ObjectValue(frame.callObj()));
         for (AliasedFormalIter fi(script); fi; fi++)
             data->args[fi.frameIndex()] = MagicScopeSlotValue(fi.scopeSlot());
     }
 }
 
 /* static */ void
-ArgumentsObject::MaybeForwardToCallObject(jit::IonJSFrameLayout *frame, HandleObject callObj,
+ArgumentsObject::MaybeForwardToCallObject(jit::JitFrameLayout *frame, HandleObject callObj,
                                           ArgumentsObject *obj, ArgumentsData *data)
 {
     JSFunction *callee = jit::CalleeTokenToFunction(frame->calleeToken());
     JSScript *script = callee->nonLazyScript();
     if (callee->isHeavyweight() && script->argsObjAliasesFormals()) {
         MOZ_ASSERT(callObj && callObj->is<CallObject>());
         obj->initFixedSlot(MAYBE_CALL_SLOT, ObjectValue(*callObj.get()));
         for (AliasedFormalIter fi(script); fi; fi++)
@@ -75,22 +75,22 @@ struct CopyFrameArgs
      * If a call object exists and the arguments object aliases formals, the
      * call object is the canonical location for formals.
      */
     void maybeForwardToCallObject(ArgumentsObject *obj, ArgumentsData *data) {
         ArgumentsObject::MaybeForwardToCallObject(frame_, obj, data);
     }
 };
 
-struct CopyIonJSFrameArgs
+struct CopyJitFrameArgs
 {
-    jit::IonJSFrameLayout *frame_;
+    jit::JitFrameLayout *frame_;
     HandleObject callObj_;
 
-    CopyIonJSFrameArgs(jit::IonJSFrameLayout *frame, HandleObject callObj)
+    CopyJitFrameArgs(jit::JitFrameLayout *frame, HandleObject callObj)
       : frame_(frame), callObj_(callObj)
     { }
 
     void copyArgs(JSContext *, HeapValue *dstBase, unsigned totalArgs) const {
         unsigned numActuals = frame_->numActualArgs();
         unsigned numFormals = jit::CalleeTokenToFunction(frame_->calleeToken())->nargs();
         MOZ_ASSERT(numActuals <= totalArgs);
         MOZ_ASSERT(numFormals <= totalArgs);
@@ -259,24 +259,24 @@ ArgumentsObject::createUnexpected(JSCont
 {
     RootedScript script(cx, frame.script());
     RootedFunction callee(cx, frame.callee());
     CopyFrameArgs copy(frame);
     return create(cx, script, callee, frame.numActualArgs(), copy);
 }
 
 ArgumentsObject *
-ArgumentsObject::createForIon(JSContext *cx, jit::IonJSFrameLayout *frame, HandleObject scopeChain)
+ArgumentsObject::createForIon(JSContext *cx, jit::JitFrameLayout *frame, HandleObject scopeChain)
 {
     jit::CalleeToken token = frame->calleeToken();
     MOZ_ASSERT(jit::CalleeTokenIsFunction(token));
     RootedScript script(cx, jit::ScriptFromCalleeToken(token));
     RootedFunction callee(cx, jit::CalleeTokenToFunction(token));
     RootedObject callObj(cx, scopeChain->is<CallObject>() ? scopeChain.get() : nullptr);
-    CopyIonJSFrameArgs copy(frame, callObj);
+    CopyJitFrameArgs copy(frame, callObj);
     return create(cx, script, callee, frame->numActualArgs(), copy);
 }
 
 static bool
 args_delProperty(JSContext *cx, HandleObject obj, HandleId id, bool *succeeded)
 {
     ArgumentsObject &argsobj = obj->as<ArgumentsObject>();
     if (JSID_IS_INT(id)) {
--- a/js/src/vm/ArgumentsObject.h
+++ b/js/src/vm/ArgumentsObject.h
@@ -13,17 +13,17 @@
 #include "vm/NativeObject.h"
 
 namespace js {
 
 class AbstractFramePtr;
 class ScriptFrameIter;
 
 namespace jit {
-class IonJSFrameLayout;
+class JitFrameLayout;
 }
 
 /*
  * ArgumentsData stores the initial indexed arguments provided to the
  * corresponding and that function itself.  It is used to store arguments[i]
  * and arguments.callee -- up until the corresponding property is modified,
  * when the relevant value is flagged to memorialize the modification.
  */
@@ -137,17 +137,17 @@ class ArgumentsObject : public NativeObj
     /*
      * Purposefully disconnect the returned arguments object from the frame
      * by always creating a new copy that does not alias formal parameters.
      * This allows function-local analysis to determine that formals are
      * not aliased and generally simplifies arguments objects.
      */
     static ArgumentsObject *createUnexpected(JSContext *cx, ScriptFrameIter &iter);
     static ArgumentsObject *createUnexpected(JSContext *cx, AbstractFramePtr frame);
-    static ArgumentsObject *createForIon(JSContext *cx, jit::IonJSFrameLayout *frame,
+    static ArgumentsObject *createForIon(JSContext *cx, jit::JitFrameLayout *frame,
                                          HandleObject scopeChain);
 
     /*
      * Return the initial length of the arguments.  This may differ from the
      * current value of arguments.length!
      */
     uint32_t initialLength() const {
         uint32_t argc = uint32_t(getFixedSlot(INITIAL_LENGTH_SLOT).toInt32()) >> PACKED_BITS_COUNT;
@@ -286,17 +286,17 @@ class ArgumentsObject : public NativeObj
         return v.magicUint32() - JS_WHY_MAGIC_COUNT;
     }
     static bool IsMagicScopeSlotValue(const Value &v) {
         return v.isMagic() && v.magicUint32() > JS_WHY_MAGIC_COUNT;
     }
 
     static void MaybeForwardToCallObject(AbstractFramePtr frame, ArgumentsObject *obj,
                                          ArgumentsData *data);
-    static void MaybeForwardToCallObject(jit::IonJSFrameLayout *frame, HandleObject callObj,
+    static void MaybeForwardToCallObject(jit::JitFrameLayout *frame, HandleObject callObj,
                                          ArgumentsObject *obj, ArgumentsData *data);
 };
 
 class NormalArgumentsObject : public ArgumentsObject
 {
   public:
     static const Class class_;
 
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -1816,17 +1816,17 @@ class MOZ_STACK_CLASS ExecutionObservabl
 
 /* static */ bool
 Debugger::updateExecutionObservabilityOfFrames(JSContext *cx, const ExecutionObservableSet &obs,
                                                IsObserving observing)
 {
     AutoSuppressProfilerSampling suppressProfilerSampling(cx);
 
     {
-        jit::IonContext ictx(cx, nullptr);
+        jit::JitContext jctx(cx, nullptr);
         if (!jit::RecompileOnStackBaselineScriptsForDebugMode(cx, obs, observing)) {
             js_ReportOutOfMemory(cx);
             return false;
         }
     }
 
     for (ScriptFrameIter iter(cx, ScriptFrameIter::ALL_CONTEXTS,
                               ScriptFrameIter::GO_THROUGH_SAVED);
@@ -5074,17 +5074,17 @@ UpdateFrameIterPc(FrameIter &iter)
         // need to update pc is because we might get the same Debugger.Frame
         // object for multiple re-entries into debugger code from debuggee
         // code. This reentrancy is not possible with rematerialized frames,
         // because when returning to debuggee code, we would have bailed out
         // to baseline.
         //
         // We walk the stack to assert that it doesn't need updating.
         jit::RematerializedFrame *frame = iter.abstractFramePtr().asRematerializedFrame();
-        jit::IonJSFrameLayout *jsFrame = (jit::IonJSFrameLayout *)frame->top();
+        jit::JitFrameLayout *jsFrame = (jit::JitFrameLayout *)frame->top();
         jit::JitActivation *activation = iter.activation()->asJit();
 
         ActivationIterator activationIter(activation->cx()->perThreadData);
         while (activationIter.activation() != activation)
             ++activationIter;
 
         jit::JitFrameIterator jitIter(activationIter);
         while (!jitIter.isIonJS() || jitIter.jsFrame() != jsFrame)
--- a/js/src/vm/ForkJoin.cpp
+++ b/js/src/vm/ForkJoin.cpp
@@ -1575,19 +1575,19 @@ ForkJoinShared::executePortion(PerThread
 
 #ifdef FORKJOIN_SPEW
     // Set the maximum worker and slice number for prettier spewing.
     cx.maxWorkerId = threadPool_->numWorkers();
 #endif
 
     Spew(SpewOps, "Up");
 
-    // Make a new IonContext for the slice, which is needed if we need to
+    // Make a new JitContext for the slice, which is needed if we need to
     // re-enter the VM.
-    IonContext icx(CompileRuntime::get(cx_->runtime()),
+    JitContext jcx(CompileRuntime::get(cx_->runtime()),
                    CompileCompartment::get(cx_->compartment()),
                    nullptr);
 
     MOZ_ASSERT(!cx.bailoutRecord->bailedOut());
 
     if (!fun_->nonLazyScript()->hasParallelIonScript()) {
         // Sometimes, particularly with GCZeal, the parallel ion
         // script can be collected between starting the parallel
--- a/js/src/vm/HelperThreads.cpp
+++ b/js/src/vm/HelperThreads.cpp
@@ -982,17 +982,17 @@ HelperThread::handleAsmJSWorkload()
 
     asmData = HelperThreadState().asmJSWorklist().popCopy();
     bool success = false;
 
     do {
         AutoUnlockHelperThreadState unlock;
         PerThreadData::AutoEnterRuntime enter(threadData.ptr(), asmData->runtime);
 
-        jit::IonContext icx(asmData->mir->compartment->runtime(),
+        jit::JitContext jcx(asmData->mir->compartment->runtime(),
                             asmData->mir->compartment,
                             &asmData->mir->alloc());
 
         int64_t before = PRMJ_Now();
 
         if (!OptimizeMIR(asmData->mir))
             break;
 
@@ -1052,17 +1052,17 @@ HelperThread::handleIonWorkload()
     AutoTraceLog logCompile(logger, TraceLogger::IonCompilation);
 
     JSRuntime *rt = ionBuilder->script()->compartment()->runtimeFromAnyThread();
 
     {
         AutoUnlockHelperThreadState unlock;
         PerThreadData::AutoEnterRuntime enter(threadData.ptr(),
                                               ionBuilder->script()->runtimeFromAnyThread());
-        jit::IonContext ictx(jit::CompileRuntime::get(rt),
+        jit::JitContext jctx(jit::CompileRuntime::get(rt),
                              jit::CompileCompartment::get(ionBuilder->script()->compartment()),
                              &ionBuilder->alloc());
         ionBuilder->setBackgroundCodegen(jit::CompileBackEnd(ionBuilder));
     }
 
     FinishOffThreadIonCompile(ionBuilder);
     ionBuilder = nullptr;
     pause = false;
--- a/js/src/vm/Interpreter-inl.h
+++ b/js/src/vm/Interpreter-inl.h
@@ -758,17 +758,17 @@ ReportIfNotFunction(JSContext *cx, Handl
  * Ion directly.
  */
 class FastInvokeGuard
 {
     InvokeArgs args_;
     RootedFunction fun_;
     RootedScript script_;
 
-    // Constructing an IonContext is pretty expensive due to the TLS access,
+    // Constructing a JitContext is pretty expensive due to the TLS access,
     // so only do this if we have to.
     bool useIon_;
 
   public:
     FastInvokeGuard(JSContext *cx, const Value &fval)
       : args_(cx)
       , fun_(cx)
       , script_(cx)
@@ -798,21 +798,21 @@ class FastInvokeGuard
                     return false;
             }
             MOZ_ASSERT(fun_->nonLazyScript() == script_);
 
             jit::MethodStatus status = jit::CanEnterUsingFastInvoke(cx, script_, args_.length());
             if (status == jit::Method_Error)
                 return false;
             if (status == jit::Method_Compiled) {
-                jit::IonExecStatus result = jit::FastInvoke(cx, fun_, args_);
+                jit::JitExecStatus result = jit::FastInvoke(cx, fun_, args_);
                 if (IsErrorStatus(result))
                     return false;
 
-                MOZ_ASSERT(result == jit::IonExec_Ok);
+                MOZ_ASSERT(result == jit::JitExec_Ok);
                 return true;
             }
 
             MOZ_ASSERT(status == jit::Method_Skipped);
 
             if (script_->canIonCompile()) {
                 // This script is not yet hot. Since calling into Ion is much
                 // faster here, bump the warm-up counter a bit to account for this.
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -41,17 +41,17 @@
 #include "vm/TraceLogging.h"
 
 #include "jsatominlines.h"
 #include "jsboolinlines.h"
 #include "jsfuninlines.h"
 #include "jsinferinlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 #include "vm/Debugger-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/Probes-inl.h"
 #include "vm/ScopeObject-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
 using namespace js::gc;
@@ -404,27 +404,27 @@ js::RunScript(JSContext *cx, RunState &s
 
     state.script()->ensureNonLazyCanonicalFunction(cx);
 
     if (jit::IsIonEnabled(cx)) {
         jit::MethodStatus status = jit::CanEnter(cx, state);
         if (status == jit::Method_Error)
             return false;
         if (status == jit::Method_Compiled) {
-            jit::IonExecStatus status = jit::IonCannon(cx, state);
+            jit::JitExecStatus status = jit::IonCannon(cx, state);
             return !IsErrorStatus(status);
         }
     }
 
     if (jit::IsBaselineEnabled(cx)) {
         jit::MethodStatus status = jit::CanEnterBaselineMethod(cx, state);
         if (status == jit::Method_Error)
             return false;
         if (status == jit::Method_Compiled) {
-            jit::IonExecStatus status = jit::EnterBaselineMethod(cx, state);
+            jit::JitExecStatus status = jit::EnterBaselineMethod(cx, state);
             return !IsErrorStatus(status);
         }
     }
 
     if (state.isInvoke()) {
         InvokeState &invoke = *state.asInvoke();
         TypeMonitorCall(cx, invoke.args(), invoke.constructing());
     }
@@ -1671,23 +1671,23 @@ END_CASE(JSOP_LABEL)
 CASE(JSOP_LOOPENTRY)
     // Attempt on-stack replacement with Baseline code.
     if (jit::IsBaselineEnabled(cx)) {
         jit::MethodStatus status = jit::CanEnterBaselineAtBranch(cx, REGS.fp(), false);
         if (status == jit::Method_Error)
             goto error;
         if (status == jit::Method_Compiled) {
             bool wasSPS = REGS.fp()->hasPushedSPSFrame();
-            jit::IonExecStatus maybeOsr = jit::EnterBaselineAtBranch(cx, REGS.fp(), REGS.pc);
+            jit::JitExecStatus maybeOsr = jit::EnterBaselineAtBranch(cx, REGS.fp(), REGS.pc);
 
             // We failed to call into baseline at all, so treat as an error.
-            if (maybeOsr == jit::IonExec_Aborted)
+            if (maybeOsr == jit::JitExec_Aborted)
                 goto error;
 
-            interpReturnOK = (maybeOsr == jit::IonExec_Ok);
+            interpReturnOK = (maybeOsr == jit::JitExec_Ok);
 
             // Pop the SPS frame pushed by the interpreter.  (The compiled version of the
             // function popped a copy of the frame pushed by the OSR trampoline.)
             if (wasSPS)
                 cx->runtime()->spsProfiler.exit(script, script->functionNonDelazifying());
 
             if (activation.entryFrame() != REGS.fp())
                 goto jit_return_pop_frame;
@@ -2542,30 +2542,30 @@ CASE(JSOP_FUNCALL)
         if (newType)
             state.setUseNewType();
 
         if (!newType && jit::IsIonEnabled(cx)) {
             jit::MethodStatus status = jit::CanEnter(cx, state);
             if (status == jit::Method_Error)
                 goto error;
             if (status == jit::Method_Compiled) {
-                jit::IonExecStatus exec = jit::IonCannon(cx, state);
+                jit::JitExecStatus exec = jit::IonCannon(cx, state);
                 CHECK_BRANCH();
                 REGS.sp = args.spAfterCall();
                 interpReturnOK = !IsErrorStatus(exec);
                 goto jit_return;
             }
         }
 
         if (jit::IsBaselineEnabled(cx)) {
             jit::MethodStatus status = jit::CanEnterBaselineMethod(cx, state);
             if (status == jit::Method_Error)
                 goto error;
             if (status == jit::Method_Compiled) {
-                jit::IonExecStatus exec = jit::EnterBaselineMethod(cx, state);
+                jit::JitExecStatus exec = jit::EnterBaselineMethod(cx, state);
                 CHECK_BRANCH();
                 REGS.sp = args.spAfterCall();
                 interpReturnOK = !IsErrorStatus(exec);
                 goto jit_return;
             }
         }
     }
 
--- a/js/src/vm/Stack.cpp
+++ b/js/src/vm/Stack.cpp
@@ -1506,28 +1506,28 @@ jit::JitActivation::registerIonFrameReco
     MOZ_ASSERT(!maybeIonFrameRecovery(results.frame()));
     if (!ionRecovery_.append(mozilla::Move(results)))
         return false;
 
     return true;
 }
 
 jit::RInstructionResults *
-jit::JitActivation::maybeIonFrameRecovery(IonJSFrameLayout *fp)
+jit::JitActivation::maybeIonFrameRecovery(JitFrameLayout *fp)
 {
     for (RInstructionResults *it = ionRecovery_.begin(); it != ionRecovery_.end(); ) {
         if (it->frame() == fp)
             return it;
     }
 
     return nullptr;
 }
 
 void
-jit::JitActivation::removeIonFrameRecovery(IonJSFrameLayout *fp)
+jit::JitActivation::removeIonFrameRecovery(JitFrameLayout *fp)
 {
     RInstructionResults *elem = maybeIonFrameRecovery(fp);
     if (!elem)
         return;
 
     ionRecovery_.erase(elem);
 }
 
--- a/js/src/vm/Stack.h
+++ b/js/src/vm/Stack.h
@@ -1346,21 +1346,21 @@ class JitActivation : public Activation
 
     void markRematerializedFrames(JSTracer *trc);
 
 
     // Register the results of on Ion frame recovery.
     bool registerIonFrameRecovery(RInstructionResults&& results);
 
     // Return the pointer to the Ion frame recovery, if it is already registered.
-    RInstructionResults *maybeIonFrameRecovery(IonJSFrameLayout *fp);
+    RInstructionResults *maybeIonFrameRecovery(JitFrameLayout *fp);
 
     // If an Ion frame recovery exists for the |fp| frame exists, then remove it
     // from the activation.
-    void removeIonFrameRecovery(IonJSFrameLayout *fp);
+    void removeIonFrameRecovery(JitFrameLayout *fp);
 
     void markIonRecovery(JSTracer *trc);
 
     // Return the bailout information if it is registered.
     const BailoutFrameInfo *bailoutData() const { return bailoutData_; }
 
     // Register the bailout data when it is constructed.
     void setBailoutData(BailoutFrameInfo *bailoutData);
--- a/js/src/vm/TraceLogging.cpp
+++ b/js/src/vm/TraceLogging.cpp
@@ -12,17 +12,17 @@
 #include <string.h>
 
 #include "jsapi.h"
 #include "jsscript.h"
 
 #include "jit/CompileWrappers.h"
 #include "vm/Runtime.h"
 
-#include "jit/IonFrames-inl.h"
+#include "jit/JitFrames-inl.h"
 
 using namespace js;
 using namespace js::jit;
 using mozilla::NativeEndian;
 
 #ifndef TRACE_LOG_DIR
 # if defined(_WIN32)
 #  define TRACE_LOG_DIR ""