Bug 909499 - Rename js::ion namespace to js::jit. r=h4writer, a=bajaj
authorJan de Mooij <jdemooij@mozilla.com>
Thu, 29 Aug 2013 12:20:25 -0400
changeset 154790 148464732cfe8ef460c5c1c7c4a077f4456d3085
parent 154789 63d366c0a224cce56cdf0d15d6ec6f9239f6821c
child 154791 47e89ff8715c00fee269a54f652b41952f0ac658
push id382
push userakeybl@mozilla.com
push dateMon, 21 Oct 2013 21:47:13 +0000
treeherdermozilla-release@5f1868ee45cb [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersh4writer, bajaj
bugs909499
milestone25.0a2
Bug 909499 - Rename js::ion namespace to js::jit. r=h4writer, a=bajaj
js/src/assembler/assembler/ARMAssembler.h
js/src/assembler/assembler/AssemblerBuffer.h
js/src/gc/Marking.cpp
js/src/gc/Marking.h
js/src/gc/Nursery.h
js/src/gc/RootMarking.cpp
js/src/gc/StoreBuffer.cpp
js/src/gc/Verifier.cpp
js/src/gc/Zone.cpp
js/src/jit/AliasAnalysis.cpp
js/src/jit/AliasAnalysis.h
js/src/jit/AsmJS.cpp
js/src/jit/AsmJSLink.cpp
js/src/jit/AsmJSModule.cpp
js/src/jit/AsmJSModule.h
js/src/jit/AsmJSSignalHandlers.cpp
js/src/jit/BacktrackingAllocator.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/BaselineCompiler.h
js/src/jit/BaselineFrame-inl.h
js/src/jit/BaselineFrame.cpp
js/src/jit/BaselineFrame.h
js/src/jit/BaselineFrameInfo.cpp
js/src/jit/BaselineFrameInfo.h
js/src/jit/BaselineHelpers.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineIC.h
js/src/jit/BaselineInspector.cpp
js/src/jit/BaselineInspector.h
js/src/jit/BaselineJIT.cpp
js/src/jit/BaselineJIT.h
js/src/jit/BaselineRegisters.h
js/src/jit/BitSet.cpp
js/src/jit/BitSet.h
js/src/jit/BytecodeAnalysis.cpp
js/src/jit/BytecodeAnalysis.h
js/src/jit/C1Spewer.cpp
js/src/jit/C1Spewer.h
js/src/jit/CodeGenerator.cpp
js/src/jit/CodeGenerator.h
js/src/jit/CompactBuffer.h
js/src/jit/CompileInfo-inl.h
js/src/jit/CompileInfo.h
js/src/jit/CompilerRoot.h
js/src/jit/EdgeCaseAnalysis.cpp
js/src/jit/EdgeCaseAnalysis.h
js/src/jit/EffectiveAddressAnalysis.cpp
js/src/jit/EffectiveAddressAnalysis.h
js/src/jit/ExecutionModeInlines.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/IonCaches.h
js/src/jit/IonCode.h
js/src/jit/IonCompartment.h
js/src/jit/IonFrameIterator-inl.h
js/src/jit/IonFrameIterator.h
js/src/jit/IonFrames-inl.h
js/src/jit/IonFrames.cpp
js/src/jit/IonFrames.h
js/src/jit/IonInstrumentation.h
js/src/jit/IonLinker.h
js/src/jit/IonMacroAssembler.cpp
js/src/jit/IonMacroAssembler.h
js/src/jit/IonSpewer.cpp
js/src/jit/IonSpewer.h
js/src/jit/IonTypes.h
js/src/jit/JSONSpewer.cpp
js/src/jit/JSONSpewer.h
js/src/jit/LICM.cpp
js/src/jit/LICM.h
js/src/jit/LIR-Common.h
js/src/jit/LIR.cpp
js/src/jit/LIR.h
js/src/jit/LinearScan.cpp
js/src/jit/LinearScan.h
js/src/jit/LiveRangeAllocator.cpp
js/src/jit/LiveRangeAllocator.h
js/src/jit/Lowering.cpp
js/src/jit/Lowering.h
js/src/jit/MCallOptimize.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/MIRGenerator.h
js/src/jit/MIRGraph.cpp
js/src/jit/MIRGraph.h
js/src/jit/MOpcodes.h
js/src/jit/MoveResolver.cpp
js/src/jit/MoveResolver.h
js/src/jit/ParallelFunctions.cpp
js/src/jit/ParallelFunctions.h
js/src/jit/ParallelSafetyAnalysis.cpp
js/src/jit/ParallelSafetyAnalysis.h
js/src/jit/PcScriptCache.h
js/src/jit/PerfSpewer.cpp
js/src/jit/PerfSpewer.h
js/src/jit/RangeAnalysis.cpp
js/src/jit/RangeAnalysis.h
js/src/jit/RegisterAllocator.cpp
js/src/jit/RegisterAllocator.h
js/src/jit/RegisterSets.h
js/src/jit/Registers.h
js/src/jit/Safepoints.cpp
js/src/jit/Safepoints.h
js/src/jit/SnapshotReader.h
js/src/jit/SnapshotWriter.h
js/src/jit/Snapshots.cpp
js/src/jit/StackSlotAllocator.h
js/src/jit/StupidAllocator.cpp
js/src/jit/StupidAllocator.h
js/src/jit/TypePolicy.cpp
js/src/jit/TypePolicy.h
js/src/jit/UnreachableCodeElimination.cpp
js/src/jit/UnreachableCodeElimination.h
js/src/jit/VMFunctions.cpp
js/src/jit/VMFunctions.h
js/src/jit/ValueNumbering.cpp
js/src/jit/ValueNumbering.h
js/src/jit/arm/Architecture-arm.cpp
js/src/jit/arm/Architecture-arm.h
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm/Assembler-arm.h
js/src/jit/arm/Bailouts-arm.cpp
js/src/jit/arm/BaselineCompiler-arm.cpp
js/src/jit/arm/BaselineCompiler-arm.h
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/CodeGenerator-arm.h
js/src/jit/arm/IonFrames-arm.cpp
js/src/jit/arm/IonFrames-arm.h
js/src/jit/arm/LIR-arm.h
js/src/jit/arm/Lowering-arm.cpp
js/src/jit/arm/Lowering-arm.h
js/src/jit/arm/MacroAssembler-arm.cpp
js/src/jit/arm/MacroAssembler-arm.h
js/src/jit/arm/MoveEmitter-arm.cpp
js/src/jit/arm/MoveEmitter-arm.h
js/src/jit/arm/Trampoline-arm.cpp
js/src/jit/shared/Assembler-shared.h
js/src/jit/shared/Assembler-x86-shared.cpp
js/src/jit/shared/Assembler-x86-shared.h
js/src/jit/shared/BaselineCompiler-shared.cpp
js/src/jit/shared/BaselineCompiler-shared.h
js/src/jit/shared/BaselineCompiler-x86-shared.cpp
js/src/jit/shared/BaselineCompiler-x86-shared.h
js/src/jit/shared/BaselineIC-x86-shared.cpp
js/src/jit/shared/CodeGenerator-shared-inl.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/CodeGenerator-x86-shared.h
js/src/jit/shared/IonAssemblerBuffer.h
js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
js/src/jit/shared/IonFrames-x86-shared.cpp
js/src/jit/shared/IonFrames-x86-shared.h
js/src/jit/shared/LIR-x86-shared.h
js/src/jit/shared/Lowering-shared-inl.h
js/src/jit/shared/Lowering-shared.cpp
js/src/jit/shared/Lowering-shared.h
js/src/jit/shared/Lowering-x86-shared.cpp
js/src/jit/shared/Lowering-x86-shared.h
js/src/jit/shared/MacroAssembler-x86-shared.h
js/src/jit/shared/MoveEmitter-x86-shared.cpp
js/src/jit/shared/MoveEmitter-x86-shared.h
js/src/jit/x64/Architecture-x64.h
js/src/jit/x64/Assembler-x64.cpp
js/src/jit/x64/Assembler-x64.h
js/src/jit/x64/Bailouts-x64.cpp
js/src/jit/x64/BaselineCompiler-x64.cpp
js/src/jit/x64/BaselineCompiler-x64.h
js/src/jit/x64/BaselineHelpers-x64.h
js/src/jit/x64/BaselineIC-x64.cpp
js/src/jit/x64/BaselineRegisters-x64.h
js/src/jit/x64/CodeGenerator-x64.cpp
js/src/jit/x64/CodeGenerator-x64.h
js/src/jit/x64/LIR-x64.h
js/src/jit/x64/Lowering-x64.cpp
js/src/jit/x64/Lowering-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/Architecture-x86.h
js/src/jit/x86/Assembler-x86.cpp
js/src/jit/x86/Assembler-x86.h
js/src/jit/x86/Bailouts-x86.cpp
js/src/jit/x86/BaselineCompiler-x86.cpp
js/src/jit/x86/BaselineCompiler-x86.h
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/CodeGenerator-x86.cpp
js/src/jit/x86/CodeGenerator-x86.h
js/src/jit/x86/LIR-x86.h
js/src/jit/x86/Lowering-x86.cpp
js/src/jit/x86/Lowering-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.cpp
js/src/jsapi.h
js/src/jscntxt.cpp
js/src/jscntxtinlines.h
js/src/jscompartment.cpp
js/src/jscompartment.h
js/src/jsdbgapi.cpp
js/src/jsfun.cpp
js/src/jsgc.cpp
js/src/jsgc.h
js/src/jsinfer.cpp
js/src/jsinfer.h
js/src/jsinferinlines.h
js/src/jsmemorymetrics.cpp
js/src/jsopcode.cpp
js/src/jsopcode.h
js/src/jsscript.cpp
js/src/jsscript.h
js/src/jsworkers.cpp
js/src/jsworkers.h
js/src/shell/js.cpp
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArgumentsObject.h
js/src/vm/Debugger.cpp
js/src/vm/Debugger.h
js/src/vm/ForkJoin.cpp
js/src/vm/ForkJoin.h
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/src/vm/Runtime.cpp
js/src/vm/Runtime.h
js/src/vm/SPSProfiler.cpp
js/src/vm/Stack.cpp
js/src/vm/Stack.h
--- a/js/src/assembler/assembler/ARMAssembler.h
+++ b/js/src/assembler/assembler/ARMAssembler.h
@@ -39,17 +39,17 @@
 #if ENABLE_ASSEMBLER && WTF_CPU_ARM_TRADITIONAL
 
 #include "assembler/assembler/AssemblerBufferWithConstantPool.h"
 #include "assembler/wtf/Assertions.h"
 
 // TODO: We don't print the condition code in our spew lines. Doing this
 // is awkward whilst maintaining a consistent field width.
 namespace js {
-    namespace ion {
+    namespace jit {
         class Assembler;
     }
 }
 
 namespace JSC {
 
     typedef uint32_t ARMWord;
 
@@ -255,17 +255,17 @@ namespace JSC {
         } Shift;
 
         static const ARMWord INVALID_IMM = 0xf0000000;
         static const ARMWord InvalidBranchTarget = 0xffffffff;
         static const int DefaultPrefetching = 2;
 
         class JmpSrc {
             friend class ARMAssembler;
-            friend class js::ion::Assembler;
+            friend class js::jit::Assembler;
         public:
             JmpSrc()
                 : m_offset(-1)
             {
             }
             int offset() {return m_offset;}
 
             bool isSet() const {
@@ -278,17 +278,17 @@ namespace JSC {
             {
             }
 
             int m_offset;
         };
 
         class JmpDst {
             friend class ARMAssembler;
-            friend class js::ion::Assembler;
+            friend class js::jit::Assembler;
         public:
             JmpDst()
                 : m_offset(-1)
                 , m_used(false)
             {
             }
 
             bool isUsed() const { return m_used; }
--- a/js/src/assembler/assembler/AssemblerBuffer.h
+++ b/js/src/assembler/assembler/AssemblerBuffer.h
@@ -268,17 +268,17 @@ namespace JSC {
 
         void spew(const char *fmt, ...)
 #ifdef __GNUC__
             __attribute__ ((format (printf, 2, 3)))
 #endif
         {
             if (printer
 #ifdef JS_ION
-                || js::ion::IonSpewEnabled(js::ion::IonSpew_Codegen)
+                || js::jit::IonSpewEnabled(js::jit::IonSpew_Codegen)
 #endif
                 )
             {
                 // Buffer to hold the formatted string. Note that this may contain
                 // '%' characters, so do not pass it directly to printf functions.
                 char buf[200];
 
                 va_list va;
@@ -286,38 +286,38 @@ namespace JSC {
                 int i = vsnprintf(buf, sizeof(buf), fmt, va);
                 va_end(va);
 
                 if (i > -1) {
                     if (printer)
                         printer->printf("%s\n", buf);
 
 #ifdef JS_ION
-                    js::ion::IonSpew(js::ion::IonSpew_Codegen, "%s", buf);
+                    js::jit::IonSpew(js::jit::IonSpew_Codegen, "%s", buf);
 #endif
                 }
             }
         }
 
         static void staticSpew(const char *fmt, ...)
 #ifdef __GNUC__
             __attribute__ ((format (printf, 1, 2)))
 #endif
         {
 #ifdef JS_ION
-            if (js::ion::IonSpewEnabled(js::ion::IonSpew_Codegen)) {
+            if (js::jit::IonSpewEnabled(js::jit::IonSpew_Codegen)) {
                 char buf[200];
 
                 va_list va;
                 va_start(va, fmt);
                 int i = vsnprintf(buf, sizeof(buf), fmt, va);
                 va_end(va);
 
                 if (i > -1)
-                    js::ion::IonSpew(js::ion::IonSpew_Codegen, "%s", buf);
+                    js::jit::IonSpew(js::jit::IonSpew_Codegen, "%s", buf);
             }
 #endif
         }
     };
 
 } // namespace JSC
 
 #endif // ENABLE(ASSEMBLER)
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -80,17 +80,17 @@ namespace js {
 namespace gc {
 
 static void MarkChildren(JSTracer *trc, JSString *str);
 static void MarkChildren(JSTracer *trc, JSScript *script);
 static void MarkChildren(JSTracer *trc, LazyScript *lazy);
 static void MarkChildren(JSTracer *trc, Shape *shape);
 static void MarkChildren(JSTracer *trc, BaseShape *base);
 static void MarkChildren(JSTracer *trc, types::TypeObject *type);
-static void MarkChildren(JSTracer *trc, ion::IonCode *code);
+static void MarkChildren(JSTracer *trc, jit::IonCode *code);
 
 } /* namespace gc */
 } /* namespace js */
 
 /*** Object Marking ***/
 
 #ifdef DEBUG
 template<typename T>
@@ -359,17 +359,17 @@ Is##base##AboutToBeFinalized(type **thin
 bool                                                                                              \
 Is##base##AboutToBeFinalized(EncapsulatedPtr<type> *thingp)                                       \
 {                                                                                                 \
     return IsAboutToBeFinalized<type>(thingp->unsafeGet());                                       \
 }
 
 DeclMarkerImpl(BaseShape, BaseShape)
 DeclMarkerImpl(BaseShape, UnownedBaseShape)
-DeclMarkerImpl(IonCode, ion::IonCode)
+DeclMarkerImpl(IonCode, jit::IonCode)
 DeclMarkerImpl(Object, ArgumentsObject)
 DeclMarkerImpl(Object, ArrayBufferObject)
 DeclMarkerImpl(Object, ArrayBufferViewObject)
 DeclMarkerImpl(Object, DebugScopeObject)
 DeclMarkerImpl(Object, GlobalObject)
 DeclMarkerImpl(Object, JSObject)
 DeclMarkerImpl(Object, JSFunction)
 DeclMarkerImpl(Object, ScopeObject)
@@ -413,17 +413,17 @@ gc::MarkKind(JSTracer *trc, void **thing
         break;
       case JSTRACE_BASE_SHAPE:
         MarkInternal(trc, reinterpret_cast<BaseShape **>(thingp));
         break;
       case JSTRACE_TYPE_OBJECT:
         MarkInternal(trc, reinterpret_cast<types::TypeObject **>(thingp));
         break;
       case JSTRACE_IONCODE:
-        MarkInternal(trc, reinterpret_cast<ion::IonCode **>(thingp));
+        MarkInternal(trc, reinterpret_cast<jit::IonCode **>(thingp));
         break;
     }
 }
 
 static void
 MarkGCThingInternal(JSTracer *trc, void **thingp, const char *name)
 {
     JS_SET_TRACING_NAME(trc, name);
@@ -830,17 +830,17 @@ PushMarkStack(GCMarker *gcmarker, Shape 
     JS_ASSERT(!IsInsideNursery(thing->runtime(), thing));
 
     /* We mark shapes directly rather than pushing on the stack. */
     if (thing->markIfUnmarked(gcmarker->getMarkColor()))
         ScanShape(gcmarker, thing);
 }
 
 static void
-PushMarkStack(GCMarker *gcmarker, ion::IonCode *thing)
+PushMarkStack(GCMarker *gcmarker, jit::IonCode *thing)
 {
     JS_COMPARTMENT_ASSERT(gcmarker->runtime, thing);
     JS_ASSERT(!IsInsideNursery(thing->runtime(), thing));
 
     if (thing->markIfUnmarked(gcmarker->getMarkColor()))
         gcmarker->pushIonCode(thing);
 }
 
@@ -1154,17 +1154,17 @@ gc::MarkChildren(JSTracer *trc, types::T
         MarkShape(trc, &type->newScript->shape, "type_new_shape");
     }
 
     if (type->interpretedFunction)
         MarkObject(trc, &type->interpretedFunction, "type_function");
 }
 
 static void
-gc::MarkChildren(JSTracer *trc, ion::IonCode *code)
+gc::MarkChildren(JSTracer *trc, jit::IonCode *code)
 {
 #ifdef JS_ION
     code->trace(trc);
 #endif
 }
 
 template<typename T>
 static void
@@ -1202,17 +1202,17 @@ gc::PushArena(GCMarker *gcmarker, ArenaH
         PushArenaTyped<js::BaseShape>(gcmarker, aheader);
         break;
 
       case JSTRACE_TYPE_OBJECT:
         PushArenaTyped<js::types::TypeObject>(gcmarker, aheader);
         break;
 
       case JSTRACE_IONCODE:
-        PushArenaTyped<js::ion::IonCode>(gcmarker, aheader);
+        PushArenaTyped<js::jit::IonCode>(gcmarker, aheader);
         break;
     }
 }
 
 struct SlotArrayLayout
 {
     union {
         HeapSlot *end;
@@ -1328,17 +1328,17 @@ GCMarker::processMarkStackOther(SliceBud
         JS_ASSERT(!(addr & CellMask));
         JSObject *obj = reinterpret_cast<JSObject *>(addr);
         HeapValue *vp, *end;
         if (restoreValueArray(obj, (void **)&vp, (void **)&end))
             pushValueArray(obj, vp, end);
         else
             pushObject(obj);
     } else if (tag == IonCodeTag) {
-        MarkChildren(this, reinterpret_cast<ion::IonCode *>(addr));
+        MarkChildren(this, reinterpret_cast<jit::IonCode *>(addr));
     } else if (tag == ArenaTag) {
         ArenaHeader *aheader = reinterpret_cast<ArenaHeader *>(addr);
         AllocKind thingKind = aheader->getAllocKind();
         size_t thingSize = Arena::thingSize(thingKind);
 
         for ( ; aheader; aheader = aheader->next) {
             Arena *arena = aheader->getArena();
             FreeSpan firstSpan(aheader->getFirstFreeSpan());
@@ -1546,17 +1546,17 @@ js::TraceChildren(JSTracer *trc, void *t
         MarkChildren(trc, static_cast<LazyScript *>(thing));
         break;
 
       case JSTRACE_SHAPE:
         MarkChildren(trc, static_cast<Shape *>(thing));
         break;
 
       case JSTRACE_IONCODE:
-        MarkChildren(trc, (js::ion::IonCode *)thing);
+        MarkChildren(trc, (js::jit::IonCode *)thing);
         break;
 
       case JSTRACE_BASE_SHAPE:
         MarkChildren(trc, static_cast<BaseShape *>(thing));
         break;
 
       case JSTRACE_TYPE_OBJECT:
         MarkChildren(trc, (types::TypeObject *)thing);
--- a/js/src/gc/Marking.h
+++ b/js/src/gc/Marking.h
@@ -86,17 +86,17 @@ void Mark##base##Range(JSTracer *trc, si
 void Mark##base##RootRange(JSTracer *trc, size_t len, type **thing, const char *name);            \
 bool Is##base##Marked(type **thingp);                                                             \
 bool Is##base##Marked(EncapsulatedPtr<type> *thingp);                                             \
 bool Is##base##AboutToBeFinalized(type **thingp);                                                 \
 bool Is##base##AboutToBeFinalized(EncapsulatedPtr<type> *thingp);
 
 DeclMarker(BaseShape, BaseShape)
 DeclMarker(BaseShape, UnownedBaseShape)
-DeclMarker(IonCode, ion::IonCode)
+DeclMarker(IonCode, jit::IonCode)
 DeclMarker(Object, ArgumentsObject)
 DeclMarker(Object, ArrayBufferObject)
 DeclMarker(Object, ArrayBufferViewObject)
 DeclMarker(Object, DebugScopeObject)
 DeclMarker(Object, GlobalObject)
 DeclMarker(Object, JSObject)
 DeclMarker(Object, JSFunction)
 DeclMarker(Object, ScopeObject)
@@ -272,17 +272,17 @@ Mark(JSTracer *trc, EncapsulatedPtrObjec
 
 inline void
 Mark(JSTracer *trc, EncapsulatedPtrScript *o, const char *name)
 {
     MarkScript(trc, o, name);
 }
 
 inline void
-Mark(JSTracer *trc, HeapPtr<ion::IonCode> *code, const char *name)
+Mark(JSTracer *trc, HeapPtr<jit::IonCode> *code, const char *name)
 {
     MarkIonCode(trc, code, name);
 }
 
 /* For use by WeakMap's HashKeyRef instantiation. */
 inline void
 Mark(JSTracer *trc, JSObject **objp, const char *name)
 {
@@ -341,27 +341,27 @@ IsAboutToBeFinalized(EncapsulatedPtrScri
 {
     return IsScriptAboutToBeFinalized(scriptp);
 }
 
 #ifdef JS_ION
 /* Nonsense to get WeakCache to work with new Marking semantics. */
 
 inline bool
-IsAboutToBeFinalized(const js::ion::VMFunction **vmfunc)
+IsAboutToBeFinalized(const js::jit::VMFunction **vmfunc)
 {
     /*
      * Preserves entries in the WeakCache<VMFunction, IonCode>
      * iff the IonCode has been marked.
      */
     return true;
 }
 
 inline bool
-IsAboutToBeFinalized(ReadBarriered<js::ion::IonCode> code)
+IsAboutToBeFinalized(ReadBarriered<js::jit::IonCode> code)
 {
     return IsIonCodeAboutToBeFinalized(code.unsafeGet());
 }
 #endif
 
 inline Cell *
 ToMarkable(const Value &v)
 {
--- a/js/src/gc/Nursery.h
+++ b/js/src/gc/Nursery.h
@@ -19,17 +19,17 @@
 namespace js {
 
 class ObjectElements;
 
 namespace gc {
 class MinorCollectionTracer;
 } /* namespace gc */
 
-namespace ion {
+namespace jit {
 class CodeGenerator;
 class MacroAssembler;
 class ICStubCompiler;
 class BaselineCompiler;
 }
 
 class Nursery
 {
@@ -230,18 +230,18 @@ class Nursery
 
     /* Change the allocable space provided by the nursery. */
     void growAllocableSpace();
     void shrinkAllocableSpace();
 
     static void MinorGCCallback(JSTracer *trc, void **thingp, JSGCTraceKind kind);
 
     friend class gc::MinorCollectionTracer;
-    friend class ion::CodeGenerator;
-    friend class ion::MacroAssembler;
-    friend class ion::ICStubCompiler;
-    friend class ion::BaselineCompiler;
+    friend class jit::CodeGenerator;
+    friend class jit::MacroAssembler;
+    friend class jit::ICStubCompiler;
+    friend class jit::BaselineCompiler;
 };
 
 } /* namespace js */
 
 #endif /* JSGC_GENERATIONAL */
 #endif /* gc_Nursery_h */
--- a/js/src/gc/RootMarking.cpp
+++ b/js/src/gc/RootMarking.cpp
@@ -55,17 +55,17 @@ MarkExactStackRoot(JSTracer *trc, Rooted
     switch (kind) {
       case THING_ROOT_OBJECT:      MarkObjectRoot(trc, (JSObject **)addr, "exact-object"); break;
       case THING_ROOT_STRING:      MarkStringRoot(trc, (JSString **)addr, "exact-string"); break;
       case THING_ROOT_SCRIPT:      MarkScriptRoot(trc, (JSScript **)addr, "exact-script"); break;
       case THING_ROOT_SHAPE:       MarkShapeRoot(trc, (Shape **)addr, "exact-shape"); break;
       case THING_ROOT_BASE_SHAPE:  MarkBaseShapeRoot(trc, (BaseShape **)addr, "exact-baseshape"); break;
       case THING_ROOT_TYPE:        MarkTypeRoot(trc, (types::Type *)addr, "exact-type"); break;
       case THING_ROOT_TYPE_OBJECT: MarkTypeObjectRoot(trc, (types::TypeObject **)addr, "exact-typeobject"); break;
-      case THING_ROOT_ION_CODE:    MarkIonCodeRoot(trc, (ion::IonCode **)addr, "exact-ioncode"); break;
+      case THING_ROOT_ION_CODE:    MarkIonCodeRoot(trc, (jit::IonCode **)addr, "exact-ioncode"); break;
       case THING_ROOT_VALUE:       MarkValueRoot(trc, (Value *)addr, "exact-value"); break;
       case THING_ROOT_ID:          MarkIdRoot(trc, (jsid *)addr, "exact-id"); break;
       case THING_ROOT_PROPERTY_ID: MarkIdRoot(trc, &((js::PropertyId *)addr)->asId(), "exact-propertyid"); break;
       case THING_ROOT_BINDINGS:    ((Bindings *)addr)->trace(trc); break;
       case THING_ROOT_PROPERTY_DESCRIPTOR: ((JSPropertyDescriptor *)addr)->trace(trc); break;
       default: MOZ_ASSUME_UNREACHABLE("Invalid THING_ROOT kind"); break;
     }
 }
@@ -271,17 +271,17 @@ static void
 MarkRangeConservativelyAndSkipIon(JSTracer *trc, JSRuntime *rt, const uintptr_t *begin, const uintptr_t *end)
 {
     const uintptr_t *i = begin;
 
 #if JS_STACK_GROWTH_DIRECTION < 0 && defined(JS_ION)
     // Walk only regions in between JIT activations. Note that non-volatile
     // registers are spilled to the stack before the entry frame, ensuring
     // that the conservative scanner will still see them.
-    for (ion::JitActivationIterator iter(rt); !iter.done(); ++iter) {
+    for (jit::JitActivationIterator iter(rt); !iter.done(); ++iter) {
         uintptr_t *jitMin, *jitEnd;
         iter.jitStackRange(jitMin, jitEnd);
 
         MarkRangeConservatively(trc, i, jitMin);
         i = jitEnd;
     }
 #endif
 
@@ -517,24 +517,24 @@ AutoGCRooter::trace(JSTracer *trc)
       case HASHABLEVALUE: {
         AutoHashableValueRooter *rooter = static_cast<AutoHashableValueRooter *>(this);
         rooter->trace(trc);
         return;
       }
 
       case IONMASM: {
 #ifdef JS_ION
-        static_cast<js::ion::MacroAssembler::AutoRooter *>(this)->masm()->trace(trc);
+        static_cast<js::jit::MacroAssembler::AutoRooter *>(this)->masm()->trace(trc);
 #endif
         return;
       }
 
       case IONALLOC: {
 #ifdef JS_ION
-        static_cast<js::ion::AutoTempAllocatorRooter *>(this)->trace(trc);
+        static_cast<js::jit::AutoTempAllocatorRooter *>(this)->trace(trc);
 #endif
         return;
       }
 
       case WRAPPER: {
         /*
          * We need to use MarkValueUnbarriered here because we mark wrapper
          * roots in every slice. This is because of some rule-breaking in
@@ -695,17 +695,17 @@ js::gc::MarkRuntime(JSTracer *trc, bool 
 
     if (!trc->runtime->isHeapMinorCollecting() &&
         (!IS_GC_MARKING_TRACER(trc) || rt->atomsCompartment->zone()->isCollecting()))
     {
         MarkAtoms(trc);
 #ifdef JS_ION
         /* Any Ion wrappers survive until the runtime is being torn down. */
         if (rt->hasContexts())
-            ion::IonRuntime::Mark(trc);
+            jit::IonRuntime::Mark(trc);
 #endif
     }
 
     rt->staticStrings.trace(trc);
 
     for (ContextIter acx(rt); !acx.done(); acx.next())
         acx->mark(trc);
 
@@ -747,17 +747,17 @@ js::gc::MarkRuntime(JSTracer *trc, bool 
         /* Mark debug scopes, if present */
         if (c->debugScopes)
             c->debugScopes->mark(trc);
     }
 
     MarkInterpreterActivations(rt, trc);
 
 #ifdef JS_ION
-    ion::MarkJitActivations(rt, trc);
+    jit::MarkJitActivations(rt, trc);
 #endif
 
     if (!rt->isHeapMinorCollecting()) {
         /*
          * All JSCompartment::mark does is mark the globals for compartements
          * which have been entered. Globals aren't nursery allocated so there's
          * no need to do this for minor GCs.
          */
--- a/js/src/gc/StoreBuffer.cpp
+++ b/js/src/gc/StoreBuffer.cpp
@@ -63,17 +63,17 @@ StoreBuffer::WholeCellEdges::mark(JSTrac
 {
     JSGCTraceKind kind = GetGCThingTraceKind(tenured);
     if (kind <= JSTRACE_OBJECT) {
         MarkChildren(trc, static_cast<JSObject *>(tenured));
         return;
     }
 #ifdef JS_ION
     JS_ASSERT(kind == JSTRACE_IONCODE);
-    static_cast<ion::IonCode *>(tenured)->trace(trc);
+    static_cast<jit::IonCode *>(tenured)->trace(trc);
 #else
     MOZ_ASSUME_UNREACHABLE("Only objects can be in the wholeCellBuffer if IonMonkey is disabled.");
 #endif
 }
 
 /*** MonoTypeBuffer ***/
 
 template <typename T>
--- a/js/src/gc/Verifier.cpp
+++ b/js/src/gc/Verifier.cpp
@@ -121,17 +121,17 @@ CheckStackRootsRangeAndSkipJit(JSRuntime
     /*
      * Regions of the stack between Ion activiations are marked exactly through
      * a different mechanism. We need to skip these regions when checking the
      * stack so that we do not poison IonMonkey's things.
      */
     uintptr_t *i = begin;
 
 #if defined(JS_ION)
-    for (ion::JitActivationIterator iter(rt); !iter.done(); ++iter) {
+    for (jit::JitActivationIterator iter(rt); !iter.done(); ++iter) {
         uintptr_t *jitMin, *jitEnd;
         iter.jitStackRange(jitMin, jitEnd);
 
         uintptr_t *upto = Min(jitMin, end);
         if (upto > i)
             CheckStackRootsRange(rt, i, upto, rbegin, rend);
         else
             break;
--- a/js/src/gc/Zone.cpp
+++ b/js/src/gc/Zone.cpp
@@ -61,17 +61,17 @@ Zone::init(JSContext *cx)
     return true;
 }
 
 void
 Zone::setNeedsBarrier(bool needs, ShouldUpdateIon updateIon)
 {
 #ifdef JS_ION
     if (updateIon == UpdateIon && needs != ionUsingBarriers_) {
-        ion::ToggleBarriers(this, needs);
+        jit::ToggleBarriers(this, needs);
         ionUsingBarriers_ = needs;
     }
 #endif
 
     needsBarrier_ = needs;
 }
 
 void
@@ -190,30 +190,30 @@ Zone::discardJitCode(FreeOp *fop, bool d
         /* Assert no baseline scripts are marked as active. */
         for (CellIterUnderGC i(this, FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
             JS_ASSERT_IF(script->hasBaselineScript(), !script->baselineScript()->active());
         }
 # endif
 
         /* Mark baseline scripts on the stack as active. */
-        ion::MarkActiveBaselineScripts(this);
+        jit::MarkActiveBaselineScripts(this);
 
         /* Only mark OSI points if code is being discarded. */
-        ion::InvalidateAll(fop, this);
+        jit::InvalidateAll(fop, this);
 
         for (CellIterUnderGC i(this, FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
-            ion::FinishInvalidation(fop, script);
+            jit::FinishInvalidation(fop, script);
 
             /*
              * Discard baseline script if it's not marked as active. Note that
              * this also resets the active flag.
              */
-            ion::FinishDiscardBaselineScript(fop, script);
+            jit::FinishDiscardBaselineScript(fop, script);
 
             /*
              * Use counts for scripts are reset on GC. After discarding code we
              * need to let it warm back up to get information such as which
              * opcodes are setting array holes or accessing getter properties.
              */
             script->resetUseCount();
         }
--- a/js/src/jit/AliasAnalysis.cpp
+++ b/js/src/jit/AliasAnalysis.cpp
@@ -10,17 +10,17 @@
 
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::Array;
 
 // Iterates over the flags in an AliasSet.
 class AliasSetIterator
 {
   private:
     uint32_t flags;
--- a/js/src/jit/AliasAnalysis.h
+++ b/js/src/jit/AliasAnalysis.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_AliasAnalysis_h
 #define jit_AliasAnalysis_h
 
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MIRGraph;
 
 typedef Vector<MDefinition *, 4, IonAllocPolicy> InstructionVector;
 
 class LoopAliasInfo : public TempObject {
   private:
     LoopAliasInfo *outer_;
@@ -52,11 +52,11 @@ class AliasAnalysis
     LoopAliasInfo *loop_;
 
   public:
     AliasAnalysis(MIRGenerator *mir, MIRGraph &graph);
     bool analyze();
 };
 
 } // namespace js
-} // namespace ion
+} // namespace jit
 
 #endif /* jit_AliasAnalysis_h */
--- a/js/src/jit/AsmJS.cpp
+++ b/js/src/jit/AsmJS.cpp
@@ -25,17 +25,17 @@
 
 #include "jsfuninlines.h"
 
 #include "frontend/ParseMaps-inl.h"
 #include "frontend/ParseNode-inl.h"
 
 using namespace js;
 using namespace js::frontend;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::AddToHash;
 using mozilla::ArrayLength;
 using mozilla::DebugOnly;
 using mozilla::HashGeneric;
 using mozilla::IsNaN;
 using mozilla::IsNegativeZero;
 using mozilla::Maybe;
@@ -4691,24 +4691,24 @@ CheckFunction(ModuleCompiler &m, LifoAll
 
 static bool
 GenerateCode(ModuleCompiler &m, ModuleCompiler::Func &func, MIRGenerator &mir, LIRGraph &lir)
 {
     int64_t before = PRMJ_Now();
 
     m.masm().bind(func.code());
 
-    ScopedJSDeletePtr<CodeGenerator> codegen(ion::GenerateCode(&mir, &lir, &m.masm()));
+    ScopedJSDeletePtr<CodeGenerator> codegen(jit::GenerateCode(&mir, &lir, &m.masm()));
     if (!codegen)
         return m.fail(NULL, "internal codegen failure (probably out of memory)");
 
     if (!m.collectAccesses(mir))
         return false;
 
-    ion::IonScriptCounts *counts = codegen->extractUnassociatedScriptCounts();
+    jit::IonScriptCounts *counts = codegen->extractUnassociatedScriptCounts();
     if (counts && !m.addFunctionCounts(counts)) {
         js_delete(counts);
         return false;
     }
 
 #ifdef MOZ_VTUNE
     if (IsVTuneProfilingActive() && !m.trackProfiledFunction(func, m.masm().size()))
         return false;
@@ -5351,17 +5351,17 @@ GenerateEntry(ModuleCompiler &m, const A
     // Before calling, we must ensure sp % 16 == 0. Since (sp % 16) = 8 on
     // entry, we need to push 8 (mod 16) bytes.
     //JS_ASSERT(AlignmentAtPrologue == 8);
     JS_ASSERT(masm.framePushed() % 8 == 4);
     unsigned stackDec = numStackArgs * sizeof(double) + (masm.framePushed() >> 2) % 2 * sizeof(uint32_t);
     masm.reserveStack(stackDec);
     //JS_ASSERT(masm.framePushed() % 8 == 0);
     if(getenv("GDB_BREAK")) {
-        masm.breakpoint(js::ion::Assembler::Always);
+        masm.breakpoint(js::jit::Assembler::Always);
     }
     // Copy parameters out of argv into the registers/stack-slots specified by
     // the system ABI.
     for (ABIArgTypeIter iter(func.sig().args()); !iter.done(); iter++) {
         unsigned argOffset = iter.index() * sizeof(uint64_t);
         switch (iter->kind()) {
           case ABIArg::GPR:
             masm.ma_ldr(Operand(argv, argOffset), iter->gpr());
--- a/js/src/jit/AsmJSLink.cpp
+++ b/js/src/jit/AsmJSLink.cpp
@@ -19,17 +19,17 @@
 #include "jit/Ion.h"
 #ifdef JS_ION_PERF
 # include "jit/PerfSpewer.h"
 #endif
 
 #include "jsfuninlines.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::IsNaN;
 
 static const unsigned MODULE_FUN_SLOT = 0;
 
 static bool
 LinkFail(JSContext *cx, const char *str)
 {
@@ -343,17 +343,17 @@ CallAsmJS(JSContext *cx, unsigned argc, 
             if (!ToNumber(cx, v, (double*)&coercedArgs[i]))
                 return false;
             break;
         }
     }
 
     {
         AsmJSActivation activation(cx, module);
-        ion::IonContext ictx(cx, NULL);
+        jit::IonContext ictx(cx, NULL);
         JitActivation jitActivation(cx, /* firstFrameIsConstructing = */ false, /* active */ false);
 
         // Call into generated code.
 #ifdef JS_CPU_ARM
         if (!func.code()(coercedArgs.begin(), module.globalData()))
             return false;
 #else
         if (!func.code()(coercedArgs.begin()))
--- a/js/src/jit/AsmJSModule.cpp
+++ b/js/src/jit/AsmJSModule.cpp
@@ -79,21 +79,21 @@ AsmJSModule::patchHeapAccesses(ArrayBuff
 #if defined(JS_CPU_X86)
     void *heapOffset = (void*)heap->dataPointer();
     void *heapLength = (void*)heap->byteLength();
     for (unsigned i = 0; i < heapAccesses_.length(); i++) {
         JSC::X86Assembler::setPointer(heapAccesses_[i].patchLengthAt(code_), heapLength);
         JSC::X86Assembler::setPointer(heapAccesses_[i].patchOffsetAt(code_), heapOffset);
     }
 #elif defined(JS_CPU_ARM)
-    ion::IonContext ic(cx, NULL);
-    ion::AutoFlushCache afc("patchBoundsCheck");
+    jit::IonContext ic(cx, NULL);
+    jit::AutoFlushCache afc("patchBoundsCheck");
     uint32_t bits = mozilla::CeilingLog2(heap->byteLength());
     for (unsigned i = 0; i < heapAccesses_.length(); i++)
-        ion::Assembler::updateBoundsCheck(bits, (ion::Instruction*)(heapAccesses_[i].offset() + code_));
+        jit::Assembler::updateBoundsCheck(bits, (jit::Instruction*)(heapAccesses_[i].offset() + code_));
 #endif
 }
 
 AsmJSModule::~AsmJSModule()
 {
     if (code_) {
         for (unsigned i = 0; i < numExits(); i++) {
             AsmJSModule::ExitDatum &exitDatum = exitIndexToGlobalDatum(i);
@@ -102,16 +102,16 @@ AsmJSModule::~AsmJSModule()
 
             if (!exitDatum.fun->hasScript())
                 continue;
 
             JSScript *script = exitDatum.fun->nonLazyScript();
             if (!script->hasIonScript())
                 continue;
 
-            ion::DependentAsmJSModuleExit exit(this, i);
+            jit::DependentAsmJSModuleExit exit(this, i);
             script->ionScript()->removeDependentAsmJSModule(exit);
         }
     }
 
     for (size_t i = 0; i < numFunctionCounts(); i++)
         js_delete(functionCounts(i));
 }
--- a/js/src/jit/AsmJSModule.h
+++ b/js/src/jit/AsmJSModule.h
@@ -300,19 +300,19 @@ class AsmJSModule
             columnIndex(column)
         { }
     };
 #endif
 
 #if defined(JS_ION_PERF)
     struct ProfiledBlocksFunction : public ProfiledFunction
     {
-        ion::PerfSpewer::BasicBlocksVector blocks;
+        jit::PerfSpewer::BasicBlocksVector blocks;
 
-        ProfiledBlocksFunction(JSAtom *name, unsigned start, unsigned end, ion::PerfSpewer::BasicBlocksVector &blocksVector)
+        ProfiledBlocksFunction(JSAtom *name, unsigned start, unsigned end, jit::PerfSpewer::BasicBlocksVector &blocksVector)
           : ProfiledFunction(name, start, end), blocks(mozilla::Move(blocksVector))
         { }
 
         ProfiledBlocksFunction(const ProfiledBlocksFunction &copy)
           : ProfiledFunction(copy.name, copy.startCodeOffset, copy.endCodeOffset), blocks(mozilla::Move(copy.blocks))
         { }
     };
 #endif
@@ -342,18 +342,18 @@ class AsmJSModule
                 scriptSource->decref();
         }
     };
 
   private:
     typedef Vector<ExportedFunction, 0, SystemAllocPolicy> ExportedFunctionVector;
     typedef Vector<Global, 0, SystemAllocPolicy> GlobalVector;
     typedef Vector<Exit, 0, SystemAllocPolicy> ExitVector;
-    typedef Vector<ion::AsmJSHeapAccess, 0, SystemAllocPolicy> HeapAccessVector;
-    typedef Vector<ion::IonScriptCounts *, 0, SystemAllocPolicy> FunctionCountsVector;
+    typedef Vector<jit::AsmJSHeapAccess, 0, SystemAllocPolicy> HeapAccessVector;
+    typedef Vector<jit::IonScriptCounts *, 0, SystemAllocPolicy> FunctionCountsVector;
 #if defined(MOZ_VTUNE) or defined(JS_ION_PERF)
     typedef Vector<ProfiledFunction, 0, SystemAllocPolicy> ProfiledFunctionVector;
 #endif
 
     GlobalVector                          globals_;
     ExitVector                            exits_;
     ExportedFunctionVector                exports_;
     HeapAccessVector                      heapAccesses_;
@@ -484,17 +484,17 @@ class AsmJSModule
         if (SIZE_MAX - funcPtrTableAndExitBytes_ < sizeof(ExitDatum))
             return false;
         uint32_t globalDataOffset = globalDataBytes();
         JS_STATIC_ASSERT(sizeof(ExitDatum) % sizeof(void*) == 0);
         funcPtrTableAndExitBytes_ += sizeof(ExitDatum);
         *exitIndex = unsigned(exits_.length());
         return exits_.append(Exit(ffiIndex, globalDataOffset));
     }
-    bool addFunctionCounts(ion::IonScriptCounts *counts) {
+    bool addFunctionCounts(jit::IonScriptCounts *counts) {
         return functionCounts_.append(counts);
     }
 
     bool addExportedFunction(PropertyName *name, PropertyName *maybeFieldName,
                              mozilla::MoveRef<ArgCoercionVector> argCoercions,
                              ReturnType returnType)
     {
         ExportedFunction func(name, maybeFieldName, argCoercions, returnType);
@@ -530,17 +530,17 @@ class AsmJSModule
     }
     unsigned numPerfFunctions() const {
         return perfProfiledFunctions_.length();
     }
     const ProfiledFunction &perfProfiledFunction(unsigned i) const {
         return perfProfiledFunctions_[i];
     }
 
-    bool trackPerfProfiledBlocks(JSAtom *name, unsigned startCodeOffset, unsigned endCodeOffset, ion::PerfSpewer::BasicBlocksVector &basicBlocks) {
+    bool trackPerfProfiledBlocks(JSAtom *name, unsigned startCodeOffset, unsigned endCodeOffset, jit::PerfSpewer::BasicBlocksVector &basicBlocks) {
         ProfiledBlocksFunction func(name, startCodeOffset, endCodeOffset, basicBlocks);
         return perfProfiledBlocksFunctions_.append(func);
     }
     unsigned numPerfBlocksFunctions() const {
         return perfProfiledBlocksFunctions_.length();
     }
     const ProfiledBlocksFunction perfProfiledBlocksFunction(unsigned i) const {
         return perfProfiledBlocksFunctions_[i];
@@ -568,17 +568,17 @@ class AsmJSModule
         return exits_[i];
     }
     const Exit &exit(unsigned i) const {
         return exits_[i];
     }
     unsigned numFunctionCounts() const {
         return functionCounts_.length();
     }
-    ion::IonScriptCounts *functionCounts(unsigned i) {
+    jit::IonScriptCounts *functionCounts(unsigned i) {
         return functionCounts_[i];
     }
 
     // An Exit holds bookkeeping information about an exit; the ExitDatum
     // struct overlays the actual runtime data stored in the global data
     // section.
     struct ExitDatum
     {
@@ -641,26 +641,26 @@ class AsmJSModule
         JS_ASSERT(functionBytes_ % AsmJSPageSize == 0);
         return functionBytes_;
     }
     bool containsPC(void *pc) const {
         uint8_t *code = functionCode();
         return pc >= code && pc < (code + functionBytes());
     }
 
-    bool addHeapAccesses(const ion::AsmJSHeapAccessVector &accesses) {
+    bool addHeapAccesses(const jit::AsmJSHeapAccessVector &accesses) {
         return heapAccesses_.appendAll(accesses);
     }
     unsigned numHeapAccesses() const {
         return heapAccesses_.length();
     }
-    ion::AsmJSHeapAccess &heapAccess(unsigned i) {
+    jit::AsmJSHeapAccess &heapAccess(unsigned i) {
         return heapAccesses_[i];
     }
-    const ion::AsmJSHeapAccess &heapAccess(unsigned i) const {
+    const jit::AsmJSHeapAccess &heapAccess(unsigned i) const {
         return heapAccesses_[i];
     }
     void patchHeapAccesses(ArrayBufferObject *heap, JSContext *cx);
 
     void takeOwnership(JSC::ExecutablePool *pool, uint8_t *code, size_t codeBytes, size_t totalBytes) {
         JS_ASSERT(uintptr_t(code) % AsmJSPageSize == 0);
         codePool_ = pool;
         code_ = code;
--- a/js/src/jit/AsmJSSignalHandlers.cpp
+++ b/js/src/jit/AsmJSSignalHandlers.cpp
@@ -9,17 +9,17 @@
 #include "jscntxt.h"
 
 #include "assembler/assembler/MacroAssembler.h"
 #include "jit/AsmJSModule.h"
 
 #include "vm/ObjectImpl-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 using namespace mozilla;
 
 #if defined(XP_WIN)
 # define XMM_sig(p,i) ((p)->Xmm##i)
 # define EIP_sig(p) ((p)->Eip)
 # define RIP_sig(p) ((p)->Rip)
 # define RAX_sig(p) ((p)->Rax)
 # define RCX_sig(p) ((p)->Rcx)
--- a/js/src/jit/BacktrackingAllocator.cpp
+++ b/js/src/jit/BacktrackingAllocator.cpp
@@ -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/. */
 
 #include "jit/BacktrackingAllocator.h"
 
 #include "jsprf.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 bool
 BacktrackingAllocator::init()
 {
     RegisterSet remainingRegisters(allRegisters_);
     while (!remainingRegisters.empty(/* float = */ false)) {
--- a/js/src/jit/BacktrackingAllocator.h
+++ b/js/src/jit/BacktrackingAllocator.h
@@ -14,17 +14,17 @@
 #include "jit/LiveRangeAllocator.h"
 
 // Backtracking priority queue based register allocator based on that described
 // in the following blog post:
 //
 // http://blog.llvm.org/2011/09/greedy-register-allocation-in-llvm-30.html
 
 namespace js {
-namespace ion {
+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.
@@ -227,12 +227,12 @@ class BacktrackingAllocator : public Liv
 
     bool chooseIntervalSplit(LiveInterval *interval);
     bool trySplitAcrossHotcode(LiveInterval *interval, bool *success);
     bool trySplitAfterLastRegisterUse(LiveInterval *interval, bool *success);
     bool splitAtAllRegisterUses(LiveInterval *interval);
     bool splitAcrossCalls(LiveInterval *interval);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_BacktrackingAllocator_h */
--- a/js/src/jit/Bailouts.cpp
+++ b/js/src/jit/Bailouts.cpp
@@ -16,17 +16,17 @@
 #include "jit/IonCompartment.h"
 #include "jit/IonSpewer.h"
 #include "jit/SnapshotReader.h"
 #include "vm/Interpreter.h"
 
 #include "vm/Stack-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // These constructor are exactly the same except for the type of the iterator
 // which is given to the SnapshotIterator constructor. Doing so avoid the
 // creation of virtual functions for the IonIterator but may introduce some
 // weirdness as IonInlineIterator is using an IonFrameIterator reference.
 //
 // If a function relies on ionScript() or to use OsiIndex(), due to the
 // lack of virtual, these functions will use the IonFrameIterator reference
@@ -60,17 +60,17 @@ IonBailoutIterator::dump() const
             ++frames;
         }
     } else {
         IonFrameIterator::dump();
     }
 }
 
 uint32_t
-ion::Bailout(BailoutStack *sp, BaselineBailoutInfo **bailoutInfo)
+jit::Bailout(BailoutStack *sp, BaselineBailoutInfo **bailoutInfo)
 {
     JS_ASSERT(bailoutInfo);
     JSContext *cx = GetIonContext()->cx;
     // We don't have an exit frame.
     cx->mainThread().ionTop = NULL;
     JitActivationIterator jitActivations(cx->runtime());
     IonBailoutIterator iter(jitActivations, sp);
     JitActivation *activation = jitActivations.activation()->asJit();
@@ -88,17 +88,17 @@ ion::Bailout(BailoutStack *sp, BaselineB
 
     if (retval != BAILOUT_RETURN_OK)
         EnsureExitFrame(iter.jsFrame());
 
     return retval;
 }
 
 uint32_t
-ion::InvalidationBailout(InvalidationBailoutStack *sp, size_t *frameSizeOut,
+jit::InvalidationBailout(InvalidationBailoutStack *sp, size_t *frameSizeOut,
                          BaselineBailoutInfo **bailoutInfo)
 {
     sp->checkInvariants();
 
     JSContext *cx = GetIonContext()->cx;
 
     // We don't have an exit frame.
     cx->mainThread().ionTop = NULL;
@@ -137,29 +137,29 @@ ion::InvalidationBailout(InvalidationBai
 
     iter.ionScript()->decref(cx->runtime()->defaultFreeOp());
 
     return retval;
 }
 
 // Initialize the decl env Object, call object, and any arguments obj of the current frame.
 bool
-ion::EnsureHasScopeObjects(JSContext *cx, AbstractFramePtr fp)
+jit::EnsureHasScopeObjects(JSContext *cx, AbstractFramePtr fp)
 {
     if (fp.isFunctionFrame() &&
         fp.fun()->isHeavyweight() &&
         !fp.hasCallObj())
     {
         return fp.initFunctionScopeObjects(cx);
     }
     return true;
 }
 
 bool
-ion::CheckFrequentBailouts(JSContext *cx, JSScript *script)
+jit::CheckFrequentBailouts(JSContext *cx, JSScript *script)
 {
     // Invalidate if this script keeps bailing out without invalidation. Next time
     // we compile this script LICM will be disabled.
 
     if (script->hasIonScript() &&
         script->ionScript()->numBailouts() >= js_IonOptions.frequentBailoutThreshold &&
         !script->hadFrequentBailouts)
     {
--- a/js/src/jit/Bailouts.h
+++ b/js/src/jit/Bailouts.h
@@ -9,17 +9,17 @@
 
 #include "jstypes.h"
 
 #include "jit/IonFrameIterator.h"
 #include "jit/IonFrames.h"
 #include "vm/Stack.h"
 
 namespace js {
-namespace ion {
+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
 //       fails.
 //   (2) A check or assumption held by the JIT is invalidated by the VM, and
 //       JIT code must be thrown away. This includes the GC possibly deciding
 //       to evict live JIT code, or a Type Inference reflow.
@@ -156,12 +156,12 @@ uint32_t Bailout(BailoutStack *sp, Basel
 // Called from the invalidation thunk. Returns a BAILOUT_* error code.
 uint32_t InvalidationBailout(InvalidationBailoutStack *sp, size_t *frameSizeOut,
                              BaselineBailoutInfo **info);
 
 uint32_t FinishBailoutToBaseline(BaselineBailoutInfo *bailoutInfo);
 
 bool CheckFrequentBailouts(JSContext *cx, JSScript *script);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_Bailouts_h */
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -10,17 +10,17 @@
 #include "jit/CompileInfo.h"
 #include "jit/IonSpewer.h"
 
 #include "jsfuninlines.h"
 
 #include "jit/IonFrames-inl.h"
 
 using namespace js;
-using namespace js::ion;
+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>
 class BufferPointer
 {
     BaselineBailoutInfo **header_;
@@ -1161,17 +1161,17 @@ InitFromBailout(JSContext *cx, HandleScr
     JS_ASSERT(rectReturnAddr);
     if (!builder.writePtr(rectReturnAddr, "ReturnAddr"))
         return false;
 
     return true;
 }
 
 uint32_t
-ion::BailoutIonToBaseline(JSContext *cx, JitActivation *activation, IonBailoutIterator &iter,
+jit::BailoutIonToBaseline(JSContext *cx, JitActivation *activation, IonBailoutIterator &iter,
                           bool invalidate, BaselineBailoutInfo **bailoutInfo)
 {
     JS_ASSERT(bailoutInfo != NULL);
     JS_ASSERT(*bailoutInfo == NULL);
 
 #if JS_TRACE_LOGGING
     TraceLogging::defaultLogger()->log(TraceLogging::INFO_ENGINE_BASELINE);
 #endif
@@ -1361,17 +1361,17 @@ HandleCachedShapeGuardFailure(JSContext 
     // an unoptimizable access was made, also preventing mono IC caching.
 
     IonSpew(IonSpew_BaselineBailouts, "Invalidating due to cached shape guard failure");
 
     return Invalidate(cx, outerScript);
 }
 
 uint32_t
-ion::FinishBailoutToBaseline(BaselineBailoutInfo *bailoutInfo)
+jit::FinishBailoutToBaseline(BaselineBailoutInfo *bailoutInfo)
 {
     // The caller pushes R0 and R1 on the stack without rooting them.
     // Since GC here is very unlikely just suppress it.
     JSContext *cx = GetIonContext()->cx;
     js::gc::AutoSuppressGC suppressGC(cx);
 
     IonSpew(IonSpew_BaselineBailouts, "  Done restoring frames");
 
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -12,17 +12,17 @@
 #include "jit/FixedList.h"
 #include "jit/IonLinker.h"
 #include "jit/IonSpewer.h"
 #include "jit/VMFunctions.h"
 
 #include "vm/Interpreter-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BaselineCompiler::BaselineCompiler(JSContext *cx, HandleScript script)
   : BaselineCompilerSpecific(cx, script)
 {
 }
 
 bool
 BaselineCompiler::init()
@@ -323,17 +323,17 @@ BaselineCompiler::emitIC(ICStub *stub, b
     entry->setReturnOffset(masm.currentOffset());
     if (!addICLoadLabel(patchOffset))
         return false;
 
     return true;
 }
 
 typedef bool (*DebugPrologueFn)(JSContext *, BaselineFrame *, bool *);
-static const VMFunction DebugPrologueInfo = FunctionInfo<DebugPrologueFn>(ion::DebugPrologue);
+static const VMFunction DebugPrologueInfo = FunctionInfo<DebugPrologueFn>(jit::DebugPrologue);
 
 bool
 BaselineCompiler::emitDebugPrologue()
 {
     if (!debugMode_)
         return true;
 
     // Load pointer to BaselineFrame in R0.
@@ -353,21 +353,21 @@ BaselineCompiler::emitDebugPrologue()
         masm.jump(&return_);
     }
     masm.bind(&done);
     return true;
 }
 
 typedef bool (*StrictEvalPrologueFn)(JSContext *, BaselineFrame *);
 static const VMFunction StrictEvalPrologueInfo =
-    FunctionInfo<StrictEvalPrologueFn>(ion::StrictEvalPrologue);
+    FunctionInfo<StrictEvalPrologueFn>(jit::StrictEvalPrologue);
 
 typedef bool (*HeavyweightFunPrologueFn)(JSContext *, BaselineFrame *);
 static const VMFunction HeavyweightFunPrologueInfo =
-    FunctionInfo<HeavyweightFunPrologueFn>(ion::HeavyweightFunPrologue);
+    FunctionInfo<HeavyweightFunPrologueFn>(jit::HeavyweightFunPrologue);
 
 bool
 BaselineCompiler::initScopeChain()
 {
     RootedFunction fun(cx, function());
     if (fun) {
         // Use callee->environment as scope chain. Note that we do
         // this also for heavy-weight functions, so that the scope
@@ -2358,17 +2358,17 @@ BaselineCompiler::emit_JSOP_RETSUB()
 {
     frame.popRegsAndSync(2);
 
     ICRetSub_Fallback::Compiler stubCompiler(cx);
     return emitOpIC(stubCompiler.getStub(&stubSpace_));
 }
 
 typedef bool (*EnterBlockFn)(JSContext *, BaselineFrame *, Handle<StaticBlockObject *>);
-static const VMFunction EnterBlockInfo = FunctionInfo<EnterBlockFn>(ion::EnterBlock);
+static const VMFunction EnterBlockInfo = FunctionInfo<EnterBlockFn>(jit::EnterBlock);
 
 bool
 BaselineCompiler::emitEnterBlock()
 {
     StaticBlockObject &blockObj = script->getObject(pc)->as<StaticBlockObject>();
 
     if (JSOp(*pc) == JSOP_ENTERBLOCK) {
         for (size_t i = 0; i < blockObj.slotCount(); i++)
@@ -2403,17 +2403,17 @@ BaselineCompiler::emit_JSOP_ENTERLET0()
 
 bool
 BaselineCompiler::emit_JSOP_ENTERLET1()
 {
     return emitEnterBlock();
 }
 
 typedef bool (*LeaveBlockFn)(JSContext *, BaselineFrame *);
-static const VMFunction LeaveBlockInfo = FunctionInfo<LeaveBlockFn>(ion::LeaveBlock);
+static const VMFunction LeaveBlockInfo = FunctionInfo<LeaveBlockFn>(jit::LeaveBlock);
 
 bool
 BaselineCompiler::emitLeaveBlock()
 {
     // Call a stub to pop the block from the block chain.
     prepareVMCall();
 
     masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -2470,17 +2470,17 @@ BaselineCompiler::emit_JSOP_EXCEPTION()
         return false;
 
     frame.push(R0);
     return true;
 }
 
 typedef bool (*OnDebuggerStatementFn)(JSContext *, BaselineFrame *, jsbytecode *pc, bool *);
 static const VMFunction OnDebuggerStatementInfo =
-    FunctionInfo<OnDebuggerStatementFn>(ion::OnDebuggerStatement);
+    FunctionInfo<OnDebuggerStatementFn>(jit::OnDebuggerStatement);
 
 bool
 BaselineCompiler::emit_JSOP_DEBUGGER()
 {
     prepareVMCall();
     pushArg(ImmWord(pc));
 
     masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -2496,17 +2496,17 @@ BaselineCompiler::emit_JSOP_DEBUGGER()
         masm.loadValue(frame.addressOfReturnValue(), JSReturnOperand);
         masm.jump(&return_);
     }
     masm.bind(&done);
     return true;
 }
 
 typedef bool (*DebugEpilogueFn)(JSContext *, BaselineFrame *, bool);
-static const VMFunction DebugEpilogueInfo = FunctionInfo<DebugEpilogueFn>(ion::DebugEpilogue);
+static const VMFunction DebugEpilogueInfo = FunctionInfo<DebugEpilogueFn>(jit::DebugEpilogue);
 
 bool
 BaselineCompiler::emitReturn()
 {
     if (debugMode_) {
         // Move return value into the frame's rval slot.
         masm.storeValue(JSReturnOperand, frame.addressOfReturnValue());
         masm.or32(Imm32(BaselineFrame::HAS_RVAL), frame.addressOfFlags());
@@ -2684,17 +2684,17 @@ BaselineCompiler::emit_JSOP_CALLEE()
 bool
 BaselineCompiler::emit_JSOP_POPV()
 {
     return emit_JSOP_SETRVAL();
 }
 
 typedef bool (*NewArgumentsObjectFn)(JSContext *, BaselineFrame *, MutableHandleValue);
 static const VMFunction NewArgumentsObjectInfo =
-    FunctionInfo<NewArgumentsObjectFn>(ion::NewArgumentsObject);
+    FunctionInfo<NewArgumentsObjectFn>(jit::NewArgumentsObject);
 
 bool
 BaselineCompiler::emit_JSOP_ARGUMENTS()
 {
     frame.syncStack(0);
 
     Label done;
     if (!script->argumentsHasVarBinding() || !script->needsArgsObj()) {
--- a/js/src/jit/BaselineCompiler.h
+++ b/js/src/jit/BaselineCompiler.h
@@ -24,17 +24,17 @@
 #elif defined(JS_CPU_X64)
 # include "jit/x64/BaselineCompiler-x64.h"
 #else
 # include "jit/arm/BaselineCompiler-arm.h"
 #endif
 #include "vm/Interpreter.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 #define OPCODE_LIST(_)         \
     _(JSOP_NOP)                \
     _(JSOP_LABEL)              \
     _(JSOP_NOTEARG)            \
     _(JSOP_POP)                \
     _(JSOP_POPN)               \
     _(JSOP_DUP)                \
@@ -260,14 +260,14 @@ class BaselineCompiler : public Baseline
 
     bool addPCMappingEntry(bool addIndexEntry);
 
     void getScopeCoordinateObject(Register reg);
     Address getScopeCoordinateAddressFromObject(Register objReg, Register reg);
     Address getScopeCoordinateAddress(Register reg);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineCompiler_h */
--- a/js/src/jit/BaselineFrame-inl.h
+++ b/js/src/jit/BaselineFrame-inl.h
@@ -14,17 +14,17 @@
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/IonFrames.h"
 
 #include "vm/ScopeObject-inl.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 inline void
 BaselineFrame::pushOnScopeChain(ScopeObject &scope)
 {
     JS_ASSERT(*scopeChain() == scope.enclosingScope() ||
               *scopeChain() == scope.as<CallObject>().enclosingScope().as<DeclEnvObject>().enclosingScope());
     scopeChain_ = &scope;
 }
@@ -75,14 +75,14 @@ BaselineFrame::callObj() const
     JS_ASSERT(fun()->isHeavyweight());
 
     JSObject *obj = scopeChain();
     while (!obj->is<CallObject>())
         obj = obj->enclosingScope();
     return obj->as<CallObject>();
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineFrame_inl_h */
--- a/js/src/jit/BaselineFrame.cpp
+++ b/js/src/jit/BaselineFrame.cpp
@@ -11,17 +11,17 @@
 #include "jit/Ion.h"
 #include "vm/Debugger.h"
 #include "vm/ScopeObject.h"
 
 #include "jit/IonFrames-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 void
 BaselineFrame::trace(JSTracer *trc)
 {
     replaceCalleeToken(MarkCalleeToken(trc, calleeToken()));
 
     gc::MarkValueRoot(trc, &thisValue(), "baseline-this");
 
--- a/js/src/jit/BaselineFrame.h
+++ b/js/src/jit/BaselineFrame.h
@@ -11,17 +11,17 @@
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/IonFrames.h"
 #include "vm/Stack.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // The stack looks like this, fp is the frame pointer:
 //
 // fp+y   arguments
 // fp+x   IonJSFrameLayout (frame header)
 // fp  => saved frame pointer
 // fp-x   BaselineFrame
 //        locals
@@ -343,26 +343,26 @@ class BaselineFrame
 
     IonJSFrameLayout *framePrefix() const {
         uint8_t *fp = (uint8_t *)this + Size() + FramePointerOffset;
         return (IonJSFrameLayout *)fp;
     }
 
     // Methods below are used by the compiler.
     static size_t offsetOfCalleeToken() {
-        return FramePointerOffset + js::ion::IonJSFrameLayout::offsetOfCalleeToken();
+        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfCalleeToken();
     }
     static size_t offsetOfThis() {
-        return FramePointerOffset + js::ion::IonJSFrameLayout::offsetOfThis();
+        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfThis();
     }
     static size_t offsetOfArg(size_t index) {
-        return FramePointerOffset + js::ion::IonJSFrameLayout::offsetOfActualArg(index);
+        return FramePointerOffset + js::jit::IonJSFrameLayout::offsetOfActualArg(index);
     }
     static size_t offsetOfNumActualArgs() {
-        return FramePointerOffset + js::ion::IonJSFrameLayout::offsetOfNumActualArgs();
+        return FramePointerOffset + js::jit::IonJSFrameLayout::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.
@@ -393,14 +393,14 @@ class BaselineFrame
     static int reverseOffsetOfLocal(size_t index) {
         return -int(Size()) - (index + 1) * sizeof(Value);
     }
 };
 
 // Ensure the frame is 8-byte aligned (required on ARM).
 JS_STATIC_ASSERT(((sizeof(BaselineFrame) + BaselineFrame::FramePointerOffset) % 8) == 0);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineFrame_h */
--- a/js/src/jit/BaselineFrameInfo.cpp
+++ b/js/src/jit/BaselineFrameInfo.cpp
@@ -7,17 +7,17 @@
 #include "jit/BaselineFrameInfo.h"
 
 #include "jsanalyze.h"
 
 #include "jit/IonSpewer.h"
 #include "jit/shared/BaselineCompiler-shared.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 bool
 FrameInfo::init() {
     // One slot is always needed for this/arguments type checks.
     size_t nstack = Max(script->nslots - script->nfixed, 1);
     if (!stack.init(nstack))
         return false;
 
--- a/js/src/jit/BaselineFrameInfo.h
+++ b/js/src/jit/BaselineFrameInfo.h
@@ -15,17 +15,17 @@
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineJIT.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/BytecodeAnalysis.h"
 #include "jit/FixedList.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // FrameInfo overview.
 //
 // FrameInfo is used by the compiler to track values stored in the frame. This
 // includes locals, arguments and stack values. Locals and arguments are always
 // fully synced. Stack values can either be synced, stored as constant, stored in
 // a Value register or refer to a local slot. Syncing a StackValue ensures it's
 // stored on the stack, e.g. kind == Stack.
@@ -323,14 +323,14 @@ class FrameInfo
 #ifdef DEBUG
     // Assert the state is valid before excuting "pc".
     void assertValidState(const BytecodeInfo &info);
 #else
     inline void assertValidState(const BytecodeInfo &info) {}
 #endif
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineFrameInfo_h */
--- a/js/src/jit/BaselineHelpers.h
+++ b/js/src/jit/BaselineHelpers.h
@@ -15,16 +15,16 @@
 # include "jit/x64/BaselineHelpers-x64.h"
 #elif defined(JS_CPU_ARM)
 # include "jit/arm/BaselineHelpers-arm.h"
 #else
 # error "Unknown architecture!"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineHelpers_h */
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -14,17 +14,17 @@
 #include "jit/IonSpewer.h"
 #include "jit/VMFunctions.h"
 
 #include "jsboolinlines.h"
 
 #include "vm/Interpreter-inl.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 #ifdef DEBUG
 void
 FallbackICSpew(JSContext *cx, ICFallbackStub *stub, const char *fmt, ...)
 {
     if (IonSpewEnabled(IonSpew_BaselineICFallback)) {
         RootedScript script(cx, GetTopIonJSScript(cx));
         jsbytecode *pc = stub->icEntry()->pc(script);
@@ -847,17 +847,17 @@ PrepareOsrTempData(JSContext *cx, ICUseC
 static bool
 DoUseCountFallback(JSContext *cx, ICUseCount_Fallback *stub, BaselineFrame *frame,
                    IonOsrTempData **infoPtr)
 {
     JS_ASSERT(infoPtr);
     *infoPtr = NULL;
 
     // A TI OOM will disable TI and Ion.
-    if (!ion::IsEnabled(cx))
+    if (!jit::IsIonEnabled(cx))
         return true;
 
     RootedScript script(cx, frame->script());
     jsbytecode *pc = stub->icEntry()->pc(script);
     bool isLoopEntry = JSOp(*pc) == JSOP_LOOPENTRY;
 
     FallbackICSpew(cx, stub, "UseCount(%d)", isLoopEntry ? int(pc - script->code) : int(-1));
 
@@ -8598,10 +8598,10 @@ ICGetProp_DOMProxyShadowed::ICGetProp_DO
                                                        uint32_t pcOffset)
   : ICMonitoredStub(ICStub::GetProp_DOMProxyShadowed, stubCode, firstMonitorStub),
     shape_(shape),
     proxyHandler_(proxyHandler),
     name_(name),
     pcOffset_(pcOffset)
 { }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -15,17 +15,17 @@
 #include "jsopcode.h"
 #include "jsproxy.h"
 
 #include "gc/Heap.h"
 #include "jit/BaselineJIT.h"
 #include "jit/BaselineRegisters.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 //
 // Baseline Inline Caches are polymorphic caches that aggressively
 // share their stub code.
 //
 // Every polymorphic site contains a linked list of stubs which are
 // specific to that site.  These stubs are composed of a |StubData|
 // structure that stores parametrization information (e.g.
@@ -5615,14 +5615,14 @@ class ICRetSub_Resume : public ICStub
         { }
 
         ICStub *getStub(ICStubSpace *space) {
             return ICRetSub_Resume::New(space, getStubCode(), pcOffset_, addr_);
         }
     };
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineIC_h */
--- a/js/src/jit/BaselineInspector.cpp
+++ b/js/src/jit/BaselineInspector.cpp
@@ -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/. */
 
 #include "jit/BaselineInspector.h"
 
 #include "jit/BaselineIC.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 bool
 SetElemICInspector::sawOOBDenseWrite() const
 {
     if (!icEntry_)
         return false;
 
     // Check for a SetElem_DenseAdd stub.
--- a/js/src/jit/BaselineInspector.h
+++ b/js/src/jit/BaselineInspector.h
@@ -12,17 +12,17 @@
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/MIR.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BaselineInspector;
 
 class ICInspector
 {
   protected:
     BaselineInspector *inspector_;
     jsbytecode *pc_;
@@ -107,14 +107,14 @@ class BaselineInspector
     MIRType expectedBinaryArithSpecialization(jsbytecode *pc);
 
     bool hasSeenNonNativeGetElement(jsbytecode *pc);
     bool hasSeenNegativeIndexGetElement(jsbytecode *pc);
     bool hasSeenAccessedGetter(jsbytecode *pc);
     bool hasSeenDoubleResult(jsbytecode *pc);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineInspector_h */
--- a/js/src/jit/BaselineJIT.cpp
+++ b/js/src/jit/BaselineJIT.cpp
@@ -14,17 +14,17 @@
 #include "jit/IonSpewer.h"
 
 #include "jsopcodeinlines.h"
 
 #include "jit/IonFrames-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 /* static */ PCMappingSlotInfo::SlotLocation
 PCMappingSlotInfo::ToSlotLocation(const StackValue *stackVal)
 {
     if (stackVal->kind() == StackValue::Register) {
         if (stackVal->reg() == R0)
             return SlotInR0;
         JS_ASSERT(stackVal->reg() == R1);
@@ -77,17 +77,17 @@ IsJSDEnabled(JSContext *cx)
 {
     return cx->compartment()->debugMode() && cx->runtime()->debugHooks.callHook;
 }
 
 static IonExecStatus
 EnterBaseline(JSContext *cx, EnterJitData &data)
 {
     JS_CHECK_RECURSION(cx, return IonExec_Aborted);
-    JS_ASSERT(ion::IsBaselineEnabled(cx));
+    JS_ASSERT(jit::IsBaselineEnabled(cx));
     JS_ASSERT_IF(data.osrFrame, CheckFrame(data.osrFrame));
 
     EnterIonCode enter = cx->runtime()->ionRuntime()->enterBaseline();
 
     // Caller must construct |this| before invoking the Ion function.
     JS_ASSERT_IF(data.constructing, data.maxArgv[0].isObject());
 
     data.result.setInt32(data.numActualArgs);
@@ -120,17 +120,17 @@ EnterBaseline(JSContext *cx, EnterJitDat
     // Release temporary buffer used for OSR into Ion.
     cx->runtime()->getIonRuntime(cx)->freeOsrTempData();
 
     JS_ASSERT_IF(data.result.isMagic(), data.result.isMagic(JS_ION_ERROR));
     return data.result.isMagic() ? IonExec_Error : IonExec_Ok;
 }
 
 IonExecStatus
-ion::EnterBaselineMethod(JSContext *cx, RunState &state)
+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))
@@ -140,17 +140,17 @@ ion::EnterBaselineMethod(JSContext *cx, 
     if (status != IonExec_Ok)
         return status;
 
     state.setReturnValue(data.result);
     return IonExec_Ok;
 }
 
 IonExecStatus
-ion::EnterBaselineAtBranch(JSContext *cx, StackFrame *fp, jsbytecode *pc)
+jit::EnterBaselineAtBranch(JSContext *cx, StackFrame *fp, jsbytecode *pc)
 {
     JS_ASSERT(JSOp(*pc) == JSOP_LOOPENTRY);
 
     BaselineScript *baseline = fp->script()->baselineScript();
 
     EnterJitData data(cx);
     data.jitcode = baseline->nativeCodeForPC(fp->script(), pc);
 
@@ -226,17 +226,17 @@ BaselineCompile(JSContext *cx, HandleScr
         script->setBaselineScript(BASELINE_DISABLED_SCRIPT);
 
     return status;
 }
 
 static MethodStatus
 CanEnterBaselineJIT(JSContext *cx, HandleScript script, bool osr)
 {
-    JS_ASSERT(ion::IsBaselineEnabled(cx));
+    JS_ASSERT(jit::IsBaselineEnabled(cx));
 
     // Skip if the script has been disabled.
     if (!script->canBaselineCompile())
         return Method_Skipped;
 
     if (script->length > BaselineScript::MAX_JSSCRIPT_LENGTH)
         return Method_CantCompile;
 
@@ -277,17 +277,17 @@ CanEnterBaselineJIT(JSContext *cx, Handl
                 return status;
         }
     }
 
     return BaselineCompile(cx, script);
 }
 
 MethodStatus
-ion::CanEnterBaselineAtBranch(JSContext *cx, StackFrame *fp, bool newType)
+jit::CanEnterBaselineAtBranch(JSContext *cx, StackFrame *fp, bool newType)
 {
    // If constructing, allocate a new |this| object.
    if (fp->isConstructing() && fp->functionThis().isPrimitive()) {
        RootedObject callee(cx, &fp->callee());
        RootedObject obj(cx, CreateThisForFunction(cx, callee, newType));
        if (!obj)
            return Method_Skipped;
        fp->functionThis().setObject(*obj);
@@ -296,17 +296,17 @@ ion::CanEnterBaselineAtBranch(JSContext 
    if (!CheckFrame(fp))
        return Method_CantCompile;
 
    RootedScript script(cx, fp->script());
    return CanEnterBaselineJIT(cx, script, /* osr = */true);
 }
 
 MethodStatus
-ion::CanEnterBaselineMethod(JSContext *cx, RunState &state)
+jit::CanEnterBaselineMethod(JSContext *cx, RunState &state)
 {
     if (state.isInvoke()) {
         InvokeState &invoke = *state.asInvoke();
 
         if (invoke.args().length() > BASELINE_MAX_ARGS_LENGTH) {
             IonSpew(IonSpew_BaselineAbort, "Too many arguments (%u)", invoke.args().length());
             return Method_CantCompile;
         }
@@ -818,17 +818,17 @@ BaselineScript::purgeOptimizedStubs(Zone
             JS_ASSERT(stub->allocatedInFallbackSpace());
             stub = stub->next();
         }
     }
 #endif
 }
 
 void
-ion::FinishDiscardBaselineScript(FreeOp *fop, JSScript *script)
+jit::FinishDiscardBaselineScript(FreeOp *fop, JSScript *script)
 {
     if (!script->hasBaselineScript())
         return;
 
     if (script->baselineScript()->active()) {
         // Script is live on the stack. Keep the BaselineScript, but destroy
         // stubs allocated in the optimized stub space.
         script->baselineScript()->purgeOptimizedStubs(script->zone());
@@ -839,52 +839,52 @@ ion::FinishDiscardBaselineScript(FreeOp 
         return;
     }
 
     BaselineScript::Destroy(fop, script->baselineScript());
     script->setBaselineScript(NULL);
 }
 
 void
-ion::IonCompartment::toggleBaselineStubBarriers(bool enabled)
+jit::IonCompartment::toggleBaselineStubBarriers(bool enabled)
 {
     for (ICStubCodeMap::Enum e(*stubCodes_); !e.empty(); e.popFront()) {
         IonCode *code = *e.front().value.unsafeGet();
         code->togglePreBarriers(enabled);
     }
 }
 
 void
-ion::SizeOfBaselineData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf, size_t *data,
+jit::SizeOfBaselineData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf, size_t *data,
                         size_t *fallbackStubs)
 {
     *data = 0;
     *fallbackStubs = 0;
 
     if (script->hasBaselineScript())
         script->baselineScript()->sizeOfIncludingThis(mallocSizeOf, data, fallbackStubs);
 }
 
 void
-ion::ToggleBaselineSPS(JSRuntime *runtime, bool enable)
+jit::ToggleBaselineSPS(JSRuntime *runtime, bool enable)
 {
     for (ZonesIter zone(runtime); !zone.done(); zone.next()) {
         for (gc::CellIter i(zone, gc::FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
             if (!script->hasBaselineScript())
                 continue;
             script->baselineScript()->toggleSPS(enable);
         }
     }
 }
 
 static void
 MarkActiveBaselineScripts(JSContext *cx, const JitActivationIterator &activation)
 {
-    for (ion::IonFrameIterator iter(activation); !iter.done(); ++iter) {
+    for (jit::IonFrameIterator iter(activation); !iter.done(); ++iter) {
         switch (iter.type()) {
           case IonFrame_BaselineJS:
             iter.script()->baselineScript()->setActive();
             break;
           case IonFrame_OptimizedJS: {
             // Keep the baseline script around, since bailouts from the ion
             // jitcode might need to re-enter into the baseline jitcode.
             iter.script()->baselineScript()->setActive();
@@ -893,26 +893,26 @@ MarkActiveBaselineScripts(JSContext *cx,
             break;
           }
           default:;
         }
     }
 }
 
 void
-ion::MarkActiveBaselineScripts(Zone *zone)
+jit::MarkActiveBaselineScripts(Zone *zone)
 {
     // First check if there is a JitActivation on the stack, so that there
     // must be a valid IonContext.
     JitActivationIterator iter(zone->rt);
     if (iter.done())
         return;
 
     // If baseline is disabled, there are no baseline scripts on the stack.
     JSContext *cx = GetIonContext()->cx;
-    if (!ion::IsBaselineEnabled(cx))
+    if (!jit::IsBaselineEnabled(cx))
         return;
 
     for (; !iter.done(); ++iter) {
         if (iter.activation()->compartment()->zone() == zone)
             MarkActiveBaselineScripts(cx, iter);
     }
 }
--- a/js/src/jit/BaselineJIT.h
+++ b/js/src/jit/BaselineJIT.h
@@ -15,17 +15,17 @@
 #include "jscompartment.h"
 
 #include "ds/LifoAlloc.h"
 #include "jit/Bailouts.h"
 #include "jit/IonCode.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class StackValue;
 class ICEntry;
 class ICStub;
 
 class PCMappingSlotInfo
 {
     uint8_t slotInfo_;
@@ -328,14 +328,14 @@ uint32_t
 BailoutIonToBaseline(JSContext *cx, JitActivation *activation, IonBailoutIterator &iter,
                      bool invalidate, BaselineBailoutInfo **bailoutInfo);
 
 // Mark baseline scripts on the stack as active, so that they are not discarded
 // during GC.
 void
 MarkActiveBaselineScripts(Zone *zone);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineJIT_h */
--- a/js/src/jit/BaselineRegisters.h
+++ b/js/src/jit/BaselineRegisters.h
@@ -13,16 +13,16 @@
 # include "jit/x86/BaselineRegisters-x86.h"
 #elif defined(JS_CPU_X64)
 # include "jit/x64/BaselineRegisters-x64.h"
 #else
 # include "jit/arm/BaselineRegisters-arm.h"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_BaselineRegisters_h */
--- a/js/src/jit/BitSet.cpp
+++ b/js/src/jit/BitSet.cpp
@@ -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/. */
 
 #include "jit/BitSet.h"
 
 #include "jsutil.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BitSet *
 BitSet::New(unsigned int max)
 {
     BitSet *result = new BitSet(max);
     if (!result->init())
         return NULL;
     return result;
--- a/js/src/jit/BitSet.h
+++ b/js/src/jit/BitSet.h
@@ -7,17 +7,17 @@
 #ifndef jit_BitSet_h
 #define jit_BitSet_h
 
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/IonAllocPolicy.h"
 
 namespace js {
-namespace ion {
+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 maximum.
 class BitSet : private TempObject
 {
   public:
     static size_t RawLengthForBits(size_t bits) {
--- a/js/src/jit/BytecodeAnalysis.cpp
+++ b/js/src/jit/BytecodeAnalysis.cpp
@@ -6,17 +6,17 @@
 
 #include "jit/BytecodeAnalysis.h"
 
 #include "jsopcode.h"
 
 #include "jsopcodeinlines.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BytecodeAnalysis::BytecodeAnalysis(JSScript *script)
   : script_(script),
     infos_()
 {
 }
 
 bool
--- a/js/src/jit/BytecodeAnalysis.h
+++ b/js/src/jit/BytecodeAnalysis.h
@@ -8,17 +8,17 @@
 #define jit_BytecodeAnalysis_h
 
 #include "jscntxt.h"
 
 #include "jit/IonAllocPolicy.h"
 #include "js/Vector.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // Basic information about bytecodes in the script.  Used to help baseline compilation.
 struct BytecodeInfo
 {
     static const uint16_t MAX_STACK_DEPTH = 0xffffU;
     uint16_t stackDepth;
     bool initialized : 1;
     bool jumpTarget : 1;
@@ -51,12 +51,12 @@ class BytecodeAnalysis
     BytecodeInfo *maybeInfo(jsbytecode *pc) {
         if (infos_[pc - script_->code].initialized)
             return &infos_[pc - script_->code];
         return NULL;
     }
 };
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_BytecodeAnalysis_h */
--- a/js/src/jit/C1Spewer.cpp
+++ b/js/src/jit/C1Spewer.cpp
@@ -13,17 +13,17 @@
 
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/LinearScan.h"
 #include "jit/LIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 bool
 C1Spewer::init(const char *path)
 {
     spewout_ = fopen(path, "w");
     return (spewout_ != NULL);
 }
 
--- a/js/src/jit/C1Spewer.h
+++ b/js/src/jit/C1Spewer.h
@@ -9,17 +9,17 @@
 
 #ifdef DEBUG
 
 #include "jsscript.h"
 
 #include "js/RootingAPI.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MDefinition;
 class MInstruction;
 class MBasicBlock;
 class MIRGraph;
 class LinearScanAllocator;
 class LInstruction;
 
@@ -42,14 +42,14 @@ class C1Spewer
     void finish();
 
   private:
     void spewPass(FILE *fp, MBasicBlock *block);
     void spewIntervals(FILE *fp, LinearScanAllocator *regalloc, LInstruction *ins, size_t &nextId);
     void spewIntervals(FILE *fp, MBasicBlock *block, LinearScanAllocator *regalloc, size_t &nextId);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* DEBUG */
 
 #endif /* jit_C1Spewer_h */
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -27,23 +27,23 @@
 #include "vm/ForkJoin.h"
 
 #include "jsboolinlines.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
 #include "vm/Interpreter-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 using mozilla::Maybe;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // This out-of-line cache is used to do a double dispatch including it-self and
 // the wrapped IonCache.
 class OutOfLineUpdateCache :
   public OutOfLineCodeBase<CodeGenerator>,
   public IonCacheVisitor
 {
   private:
@@ -3315,17 +3315,17 @@ CodeGenerator::visitCreateThisWithProto(
     else
         pushArg(ToRegister(callee));
 
     return callVM(CreateThisWithProtoInfo, lir);
 }
 
 typedef JSObject *(*NewGCThingFn)(JSContext *cx, gc::AllocKind allocKind, size_t thingSize);
 static const VMFunction NewGCThingInfo =
-    FunctionInfo<NewGCThingFn>(js::ion::NewGCThing);
+    FunctionInfo<NewGCThingFn>(js::jit::NewGCThing);
 
 bool
 CodeGenerator::visitCreateThisWithTemplate(LCreateThisWithTemplate *lir)
 {
     JSObject *templateObject = lir->mir()->getTemplateObject();
     gc::AllocKind allocKind = templateObject->tenuredGetAllocKind();
     int thingSize = (int)gc::Arena::thingSize(allocKind);
     Register objReg = ToRegister(lir->output());
@@ -3711,21 +3711,21 @@ CodeGenerator::visitBinaryV(LBinaryV *li
       default:
         MOZ_ASSUME_UNREACHABLE("Unexpected binary op");
     }
 }
 
 typedef bool (*StringCompareFn)(JSContext *, HandleString, HandleString, bool *);
 typedef ParallelResult (*StringCompareParFn)(ForkJoinSlice *, HandleString, HandleString, bool *);
 static const VMFunctionsModal StringsEqualInfo = VMFunctionsModal(
-    FunctionInfo<StringCompareFn>(ion::StringsEqual<true>),
-    FunctionInfo<StringCompareParFn>(ion::StringsEqualPar));
+    FunctionInfo<StringCompareFn>(jit::StringsEqual<true>),
+    FunctionInfo<StringCompareParFn>(jit::StringsEqualPar));
 static const VMFunctionsModal StringsNotEqualInfo = VMFunctionsModal(
-    FunctionInfo<StringCompareFn>(ion::StringsEqual<false>),
-    FunctionInfo<StringCompareParFn>(ion::StringsUnequalPar));
+    FunctionInfo<StringCompareFn>(jit::StringsEqual<false>),
+    FunctionInfo<StringCompareParFn>(jit::StringsUnequalPar));
 
 bool
 CodeGenerator::emitCompareS(LInstruction *lir, JSOp op, Register left, Register right,
                             Register output, Register temp)
 {
     JS_ASSERT(lir->isCompareS() || lir->isCompareStrictS());
 
     OutOfLineCode *ool = NULL;
@@ -3784,39 +3784,39 @@ CodeGenerator::visitCompareS(LCompareS *
 
     return emitCompareS(lir, op, left, right, output, temp);
 }
 
 typedef bool (*CompareFn)(JSContext *, MutableHandleValue, MutableHandleValue, bool *);
 typedef ParallelResult (*CompareParFn)(ForkJoinSlice *, MutableHandleValue, MutableHandleValue,
                                        bool *);
 static const VMFunctionsModal EqInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::LooselyEqual<true>),
-    FunctionInfo<CompareParFn>(ion::LooselyEqualPar));
+    FunctionInfo<CompareFn>(jit::LooselyEqual<true>),
+    FunctionInfo<CompareParFn>(jit::LooselyEqualPar));
 static const VMFunctionsModal NeInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::LooselyEqual<false>),
-    FunctionInfo<CompareParFn>(ion::LooselyUnequalPar));
+    FunctionInfo<CompareFn>(jit::LooselyEqual<false>),
+    FunctionInfo<CompareParFn>(jit::LooselyUnequalPar));
 static const VMFunctionsModal StrictEqInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::StrictlyEqual<true>),
-    FunctionInfo<CompareParFn>(ion::StrictlyEqualPar));
+    FunctionInfo<CompareFn>(jit::StrictlyEqual<true>),
+    FunctionInfo<CompareParFn>(jit::StrictlyEqualPar));
 static const VMFunctionsModal StrictNeInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::StrictlyEqual<false>),
-    FunctionInfo<CompareParFn>(ion::StrictlyUnequalPar));
+    FunctionInfo<CompareFn>(jit::StrictlyEqual<false>),
+    FunctionInfo<CompareParFn>(jit::StrictlyUnequalPar));
 static const VMFunctionsModal LtInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::LessThan),
-    FunctionInfo<CompareParFn>(ion::LessThanPar));
+    FunctionInfo<CompareFn>(jit::LessThan),
+    FunctionInfo<CompareParFn>(jit::LessThanPar));
 static const VMFunctionsModal LeInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::LessThanOrEqual),
-    FunctionInfo<CompareParFn>(ion::LessThanOrEqualPar));
+    FunctionInfo<CompareFn>(jit::LessThanOrEqual),
+    FunctionInfo<CompareParFn>(jit::LessThanOrEqualPar));
 static const VMFunctionsModal GtInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::GreaterThan),
-    FunctionInfo<CompareParFn>(ion::GreaterThanPar));
+    FunctionInfo<CompareFn>(jit::GreaterThan),
+    FunctionInfo<CompareParFn>(jit::GreaterThanPar));
 static const VMFunctionsModal GeInfo = VMFunctionsModal(
-    FunctionInfo<CompareFn>(ion::GreaterThanOrEqual),
-    FunctionInfo<CompareParFn>(ion::GreaterThanOrEqualPar));
+    FunctionInfo<CompareFn>(jit::GreaterThanOrEqual),
+    FunctionInfo<CompareParFn>(jit::GreaterThanOrEqualPar));
 
 bool
 CodeGenerator::visitCompareVM(LCompareVM *lir)
 {
     pushArg(ToValue(lir, LBinaryV::RhsInput));
     pushArg(ToValue(lir, LBinaryV::LhsInput));
 
     switch (lir->mir()->jsop()) {
@@ -4287,17 +4287,17 @@ IonCompartment::generateStringConcatStub
     masm.movePtr(ImmWord((void *)NULL), output);
     masm.ret();
 
     Linker linker(masm);
     return linker.newCode(cx, JSC::OTHER_CODE);
 }
 
 typedef bool (*CharCodeAtFn)(JSContext *, HandleString, int32_t, uint32_t *);
-static const VMFunction CharCodeAtInfo = FunctionInfo<CharCodeAtFn>(ion::CharCodeAt);
+static const VMFunction CharCodeAtInfo = FunctionInfo<CharCodeAtFn>(jit::CharCodeAt);
 
 bool
 CodeGenerator::visitCharCodeAt(LCharCodeAt *lir)
 {
     Register str = ToRegister(lir->str());
     Register index = ToRegister(lir->index());
     Register output = ToRegister(lir->output());
 
@@ -4315,17 +4315,17 @@ CodeGenerator::visitCharCodeAt(LCharCode
     masm.loadPtr(charsAddr, output);
     masm.load16ZeroExtend(BaseIndex(output, index, TimesTwo, 0), output);
 
     masm.bind(ool->rejoin());
     return true;
 }
 
 typedef JSFlatString *(*StringFromCharCodeFn)(JSContext *, int32_t);
-static const VMFunction StringFromCharCodeInfo = FunctionInfo<StringFromCharCodeFn>(ion::StringFromCharCode);
+static const VMFunction StringFromCharCodeInfo = FunctionInfo<StringFromCharCodeFn>(jit::StringFromCharCode);
 
 bool
 CodeGenerator::visitFromCharCode(LFromCharCode *lir)
 {
     Register code = ToRegister(lir->code());
     Register output = ToRegister(lir->output());
 
     OutOfLineCode *ool = oolCallVM(StringFromCharCodeInfo, lir, (ArgList(), code), StoreRegisterTo(output));
@@ -4799,18 +4799,18 @@ CodeGenerator::visitOutOfLineStoreElemen
         return true;
     }
 
     JS_ASSERT(false);
     return false;
 }
 
 typedef bool (*ArrayPopShiftFn)(JSContext *, HandleObject, MutableHandleValue);
-static const VMFunction ArrayPopDenseInfo = FunctionInfo<ArrayPopShiftFn>(ion::ArrayPopDense);
-static const VMFunction ArrayShiftDenseInfo = FunctionInfo<ArrayPopShiftFn>(ion::ArrayShiftDense);
+static const VMFunction ArrayPopDenseInfo = FunctionInfo<ArrayPopShiftFn>(jit::ArrayPopDense);
+static const VMFunction ArrayShiftDenseInfo = FunctionInfo<ArrayPopShiftFn>(jit::ArrayShiftDense);
 
 bool
 CodeGenerator::emitArrayPopShift(LInstruction *lir, const MArrayPopShift *mir, Register obj,
                                  Register elementsTemp, Register lengthTemp, TypedOrValueRegister out)
 {
     OutOfLineCode *ool;
 
     if (mir->mode() == MArrayPopShift::Pop) {
@@ -4908,17 +4908,17 @@ CodeGenerator::visitArrayPopShiftT(LArra
     Register elements = ToRegister(lir->temp0());
     Register length = ToRegister(lir->temp1());
     TypedOrValueRegister out(lir->mir()->type(), ToAnyRegister(lir->output()));
     return emitArrayPopShift(lir, lir->mir(), obj, elements, length, out);
 }
 
 typedef bool (*ArrayPushDenseFn)(JSContext *, HandleObject, HandleValue, uint32_t *);
 static const VMFunction ArrayPushDenseInfo =
-    FunctionInfo<ArrayPushDenseFn>(ion::ArrayPushDense);
+    FunctionInfo<ArrayPushDenseFn>(jit::ArrayPushDense);
 
 bool
 CodeGenerator::emitArrayPush(LInstruction *lir, const MArrayPush *mir, Register obj,
                              ConstantOrRegister value, Register elementsTemp, Register length)
 {
     OutOfLineCode *ool = oolCallVM(ArrayPushDenseInfo, lir, (ArgList(), obj, value), StoreRegisterTo(length));
     if (!ool)
         return false;
@@ -5163,17 +5163,17 @@ CodeGenerator::visitIteratorNext(LIterat
     // Increase the cursor.
     masm.addPtr(Imm32(sizeof(JSString *)), Address(temp, offsetof(NativeIterator, props_cursor)));
 
     masm.bind(ool->rejoin());
     return true;
 }
 
 typedef bool (*IteratorMoreFn)(JSContext *, HandleObject, bool *);
-static const VMFunction IteratorMoreInfo = FunctionInfo<IteratorMoreFn>(ion::IteratorMore);
+static const VMFunction IteratorMoreInfo = FunctionInfo<IteratorMoreFn>(jit::IteratorMore);
 
 bool
 CodeGenerator::visitIteratorMore(LIteratorMore *lir)
 {
     const Register obj = ToRegister(lir->object());
     const Register output = ToRegister(lir->output());
     const Register temp = ToRegister(lir->temp());
 
@@ -5466,17 +5466,17 @@ CodeGenerator::link()
     ExecutionMode executionMode = gen->info().executionMode();
     JS_ASSERT(!HasIonScript(script, executionMode));
 
     uint32_t scriptFrameSize = frameClass_ == FrameSizeClass::None()
                            ? frameDepth_
                            : FrameSizeClass::FromDepth(frameDepth_).frameSize();
 
     // Check to make sure we didn't have a mid-build invalidation. If so, we
-    // will trickle to ion::Compile() and return Method_Skipped.
+    // will trickle to jit::Compile() and return Method_Skipped.
     if (cx->compartment()->types.compiledInfo.compilerOutput(cx)->isInvalidated())
         return true;
 
     // List of possible scripts that this graph may call. Currently this is
     // only tracked when compiling for parallel execution.
     CallTargetVector callTargets;
     if (executionMode == ParallelExecution)
         AddPossibleCallees(graph.mir(), callTargets);
@@ -7219,10 +7219,10 @@ CodeGenerator::visitAsmJSCheckOverRecurs
     uintptr_t *limitAddr = &gen->compartment->rt->mainThread.nativeStackLimit;
     masm.branchPtr(Assembler::AboveOrEqual,
                    AbsoluteAddress(limitAddr),
                    StackPointer,
                    lir->mir()->onError());
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/CodeGenerator.h
+++ b/js/src/jit/CodeGenerator.h
@@ -15,17 +15,17 @@
 # include "jit/x64/CodeGenerator-x64.h"
 #elif defined(JS_CPU_ARM)
 # include "jit/arm/CodeGenerator-arm.h"
 #else
 #error "CPU Not Supported"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class OutOfLineNewParallelArray;
 class OutOfLineTestObject;
 class OutOfLineNewArray;
 class OutOfLineNewObject;
 class CheckOverRecursedFailure;
 class CheckOverRecursedFailurePar;
 class OutOfLineCheckInterruptPar;
@@ -347,12 +347,12 @@ class CodeGenerator : public CodeGenerat
     bool emitStoreHoleCheck(Register elements, const LAllocation *index, LSnapshot *snapshot);
 
     // Script counts created when compiling code with no associated JSScript.
     IonScriptCounts *unassociatedScriptCounts_;
 
     PerfSpewer perfSpewer_;
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_CodeGenerator_h */
--- a/js/src/jit/CompactBuffer.h
+++ b/js/src/jit/CompactBuffer.h
@@ -8,17 +8,17 @@
 #define jit_Compactbuffer_h
 
 #include "jsalloc.h"
 
 #include "jit/IonTypes.h"
 #include "js/Vector.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class CompactBufferWriter;
 
 // CompactBuffers are byte streams designed for compressable integers. It has
 // helper functions for writing bytes, fixed-size integers, and variable-sized
 // integers. Variable sized integers are encoded in 1-5 bytes, each byte
 // containing 7 bits of the integer and a bit which specifies whether the next
 // byte is also part of the integer.
@@ -149,12 +149,12 @@ class CompactBufferWriter
 };
 
 CompactBufferReader::CompactBufferReader(const CompactBufferWriter &writer)
   : buffer_(writer.buffer()),
     end_(writer.buffer() + writer.length())
 {
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_Compactbuffer_h */
--- a/js/src/jit/CompileInfo-inl.h
+++ b/js/src/jit/CompileInfo-inl.h
@@ -7,17 +7,17 @@
 #ifndef jit_CompileInfo_inl_h
 #define jit_CompileInfo_inl_h
 
 #include "jit/CompileInfo.h"
 
 #include "jsscriptinlines.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 inline RegExpObject *
 CompileInfo::getRegExp(jsbytecode *pc) const
 {
     return script_->getRegExp(GET_UINT32_INDEX(pc));
 }
 
 inline JSFunction *
--- a/js/src/jit/CompileInfo.h
+++ b/js/src/jit/CompileInfo.h
@@ -7,17 +7,17 @@
 #ifndef jit_CompileInfo_h
 #define jit_CompileInfo_h
 
 #include "jsfun.h"
 
 #include "jit/Registers.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 inline unsigned
 StartArgSlot(JSScript *script, JSFunction *fun)
 {
     // First slot is for scope chain.
     // Second one may be for arguments object.
     return 1 + (script->argumentsHasVarBinding() ? 1 : 0);
 }
@@ -235,12 +235,12 @@ class CompileInfo
     unsigned nslots_;
     JSScript *script_;
     JSFunction *fun_;
     jsbytecode *osrPc_;
     bool constructing_;
     ExecutionMode executionMode_;
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_CompileInfo_h */
--- a/js/src/jit/CompilerRoot.h
+++ b/js/src/jit/CompilerRoot.h
@@ -11,17 +11,17 @@
 
 #include "jscntxt.h"
 
 #include "jit/Ion.h"
 #include "jit/IonAllocPolicy.h"
 #include "js/RootingAPI.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // Roots a read-only GCThing for the lifetime of a single compilation.
 // Each root is maintained in a linked list that is walked over during tracing.
 // The CompilerRoot must be heap-allocated and may not go out of scope.
 template <typename T>
 class CompilerRoot : public CompilerRootNode
 {
   public:
@@ -57,14 +57,14 @@ class CompilerRoot : public CompilerRoot
 
 typedef CompilerRoot<JSObject*> CompilerRootObject;
 typedef CompilerRoot<JSFunction*> CompilerRootFunction;
 typedef CompilerRoot<JSScript*> CompilerRootScript;
 typedef CompilerRoot<PropertyName*> CompilerRootPropertyName;
 typedef CompilerRoot<Shape*> CompilerRootShape;
 typedef CompilerRoot<Value> CompilerRootValue;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_CompilerRoot_h */
--- a/js/src/jit/EdgeCaseAnalysis.cpp
+++ b/js/src/jit/EdgeCaseAnalysis.cpp
@@ -10,17 +10,17 @@
 
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 EdgeCaseAnalysis::EdgeCaseAnalysis(MIRGenerator *mir, MIRGraph &graph)
   : mir(mir), graph(graph)
 {
 }
 
 bool
 EdgeCaseAnalysis::analyzeLate()
--- a/js/src/jit/EdgeCaseAnalysis.h
+++ b/js/src/jit/EdgeCaseAnalysis.h
@@ -5,27 +5,27 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_EdgeCaseAnalysis_h
 #define jit_EdgeCaseAnalysis_h
 
 #include "jit/MIRGenerator.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MIRGraph;
 
 class EdgeCaseAnalysis
 {
     MIRGenerator *mir;
     MIRGraph &graph;
 
   public:
     EdgeCaseAnalysis(MIRGenerator *mir, MIRGraph &graph);
     bool analyzeLate();
 };
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_EdgeCaseAnalysis_h */
--- a/js/src/jit/EffectiveAddressAnalysis.cpp
+++ b/js/src/jit/EffectiveAddressAnalysis.cpp
@@ -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/. */
 
 #include "jit/EffectiveAddressAnalysis.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 static void
 AnalyzeLsh(MBasicBlock *block, MLsh *lsh)
 {
     if (lsh->specialization() != MIRType_Int32)
         return;
 
     MDefinition *index = lsh->lhs();
--- a/js/src/jit/EffectiveAddressAnalysis.h
+++ b/js/src/jit/EffectiveAddressAnalysis.h
@@ -6,26 +6,26 @@
 
 #ifndef jit_EffectiveAddressAnalysis_h
 #define jit_EffectiveAddressAnalysis_h
 
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class EffectiveAddressAnalysis
 {
     MIRGraph &graph_;
 
   public:
     EffectiveAddressAnalysis(MIRGraph &graph)
       : graph_(graph)
     {}
 
     bool analyze();
 };
 
-} /* namespace ion */
+} /* namespace jit */
 } /* namespace js */
 
 #endif /* jit_EffectiveAddressAnalysis_h */
--- a/js/src/jit/ExecutionModeInlines.h
+++ b/js/src/jit/ExecutionModeInlines.h
@@ -7,17 +7,17 @@
 #ifndef jit_ExecutionModeInlines_h
 #define jit_ExecutionModeInlines_h
 
 #ifdef JS_ION
 
 #include "jit/CompileInfo.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static inline bool
 HasIonScript(JSScript *script, ExecutionMode cmode)
 {
     switch (cmode) {
       case SequentialExecution: return script->hasIonScript();
       case ParallelExecution: return script->hasParallelIonScript();
     }
@@ -96,14 +96,14 @@ CompilerOutputKind(ExecutionMode cmode)
 {
     switch (cmode) {
       case SequentialExecution: return types::CompilerOutput::Ion;
       case ParallelExecution: return types::CompilerOutput::ParallelIon;
     }
     MOZ_ASSUME_UNREACHABLE("No such execution mode");
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif  // JS_ION
 
 #endif /* jit_ExecutionModeInlines_h */
--- a/js/src/jit/FixedList.h
+++ b/js/src/jit/FixedList.h
@@ -8,17 +8,17 @@
 #define jit_FixedList_h
 
 #include <stddef.h>
 
 #include "jit/Ion.h"
 #include "jit/IonAllocPolicy.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // List of a fixed length, but the length is unknown until runtime.
 template <typename T>
 class FixedList
 {
     size_t length_;
     T *list_;
 
@@ -68,12 +68,12 @@ class FixedList
         return list_[index];
     }
     const T &operator [](size_t index) const {
         JS_ASSERT(index < length_);
         return list_[index];
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_FixedList_h */
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -52,67 +52,67 @@
 
 #include "jscompartmentinlines.h"
 #include "jsgcinlines.h"
 #include "jsinferinlines.h"
 
 #include "vm/Stack-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // Global variables.
-IonOptions ion::js_IonOptions;
+IonOptions jit::js_IonOptions;
 
 // Assert that IonCode is gc::Cell aligned.
 JS_STATIC_ASSERT(sizeof(IonCode) % gc::CellSize == 0);
 
 #ifdef JS_THREADSAFE
 static bool IonTLSInitialized = false;
 static unsigned IonTLSIndex;
 
 static inline IonContext *
 CurrentIonContext()
 {
     return (IonContext *)PR_GetThreadPrivate(IonTLSIndex);
 }
 
 bool
-ion::SetIonContext(IonContext *ctx)
+jit::SetIonContext(IonContext *ctx)
 {
     return PR_SetThreadPrivate(IonTLSIndex, ctx) == PR_SUCCESS;
 }
 
 #else
 
 static IonContext *GlobalIonContext;
 
 static inline IonContext *
 CurrentIonContext()
 {
     return GlobalIonContext;
 }
 
 bool
-ion::SetIonContext(IonContext *ctx)
+jit::SetIonContext(IonContext *ctx)
 {
     GlobalIonContext = ctx;
     return true;
 }
 #endif
 
 IonContext *
-ion::GetIonContext()
+jit::GetIonContext()
 {
     JS_ASSERT(CurrentIonContext());
     return CurrentIonContext();
 }
 
 IonContext *
-ion::MaybeGetIonContext()
+jit::MaybeGetIonContext()
 {
     return CurrentIonContext();
 }
 
 IonContext::IonContext(JSContext *cx, TempAllocator *temp)
   : runtime(cx->runtime()),
     cx(cx),
     compartment(cx->compartment()),
@@ -146,17 +146,17 @@ IonContext::IonContext(JSRuntime *rt)
 }
 
 IonContext::~IonContext()
 {
     SetIonContext(prev_);
 }
 
 bool
-ion::InitializeIon()
+jit::InitializeIon()
 {
 #ifdef JS_THREADSAFE
     if (!IonTLSInitialized) {
         PRStatus status = PR_NewThreadPrivateIndex(&IonTLSIndex, NULL);
         if (status != PR_SUCCESS)
             return false;
 
         IonTLSInitialized = true;
@@ -346,17 +346,17 @@ IonCompartment::ensureIonStubsExist(JSCo
             return false;
     }
 #endif
 
     return true;
 }
 
 void
-ion::FinishOffThreadBuilder(IonBuilder *builder)
+jit::FinishOffThreadBuilder(IonBuilder *builder)
 {
     ExecutionMode executionMode = builder->info().executionMode();
 
     // Clean up if compilation did not succeed.
     if (CompilingOffThread(builder->script(), executionMode)) {
         types::TypeCompartment &types = builder->script()->compartment()->types;
         builder->recompileInfo.compilerOutput(types)->invalidate();
         SetIonScript(builder->script(), executionMode, NULL);
@@ -930,17 +930,17 @@ IonScript::detachDependentAsmJSModules(F
         DependentAsmJSModuleExit exit = dependentAsmJSModules->begin()[i];
         exit.module->detachIonCompilation(exit.exitIndex);
     }
     fop->delete_(dependentAsmJSModules);
     dependentAsmJSModules = NULL;
 }
 
 void
-ion::ToggleBarriers(JS::Zone *zone, bool needs)
+jit::ToggleBarriers(JS::Zone *zone, bool needs)
 {
     IonContext ictx(zone->rt);
     if (!zone->rt->hasIonRuntime())
         return;
 
     AutoFlushCache afc("ToggleBarriers", zone->rt->ionRuntime());
     for (gc::CellIterUnderGC i(zone, gc::FINALIZE_SCRIPT); !i.done(); i.next()) {
         JSScript *script = i.get<JSScript>();
@@ -952,17 +952,17 @@ ion::ToggleBarriers(JS::Zone *zone, bool
 
     for (CompartmentsInZoneIter comp(zone); !comp.done(); comp.next()) {
         if (comp->ionCompartment())
             comp->ionCompartment()->toggleBaselineStubBarriers(needs);
     }
 }
 
 namespace js {
-namespace ion {
+namespace jit {
 
 bool
 OptimizeMIR(MIRGenerator *mir)
 {
     MIRGraph &graph = mir->graph();
 
     IonSpewPass("BuildSSA");
     AssertBasicGraphCoherency(graph);
@@ -1562,18 +1562,18 @@ CanIonCompileScript(JSContext *cx, Handl
 
     return CheckScriptSize(cx, script) == Method_Compiled;
 }
 
 static MethodStatus
 Compile(JSContext *cx, HandleScript script, BaselineFrame *osrFrame, jsbytecode *osrPc,
         bool constructing, ExecutionMode executionMode)
 {
-    JS_ASSERT(ion::IsEnabled(cx));
-    JS_ASSERT(ion::IsBaselineEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
+    JS_ASSERT(jit::IsBaselineEnabled(cx));
     JS_ASSERT_IF(osrPc != NULL, (JSOp)*osrPc == JSOP_LOOPENTRY);
 
     if (executionMode == SequentialExecution && !script->hasBaselineScript())
         return Method_Skipped;
 
     if (cx->compartment()->debugMode()) {
         IonSpew(IonSpew_Abort, "debugging");
         return Method_CantCompile;
@@ -1607,26 +1607,26 @@ Compile(JSContext *cx, HandleScript scri
     AbortReason reason = IonCompile(cx, script, osrFrame, osrPc, constructing, executionMode);
     if (reason == AbortReason_Disable)
         return Method_CantCompile;
 
     // Compilation succeeded or we invalidated right away or an inlining/alloc abort
     return HasIonScript(script, executionMode) ? Method_Compiled : Method_Skipped;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 // Decide if a transition from interpreter execution to Ion code should occur.
 // May compile or recompile the target JSScript.
 MethodStatus
-ion::CanEnterAtBranch(JSContext *cx, JSScript *script, BaselineFrame *osrFrame,
+jit::CanEnterAtBranch(JSContext *cx, JSScript *script, BaselineFrame *osrFrame,
                       jsbytecode *pc, bool isConstructing)
 {
-    JS_ASSERT(ion::IsEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
     JS_ASSERT((JSOp)*pc == JSOP_LOOPENTRY);
 
     // Skip if the script has been disabled.
     if (!script->canIonCompile())
         return Method_Skipped;
 
     // Skip if the script is being compiled off thread.
     if (script->isIonCompilingOffThread())
@@ -1668,19 +1668,19 @@ ion::CanEnterAtBranch(JSContext *cx, JSS
     }
 
     script->ionScript()->resetOsrPcMismatchCounter();
 
     return Method_Compiled;
 }
 
 MethodStatus
-ion::CanEnter(JSContext *cx, RunState &state)
+jit::CanEnter(JSContext *cx, RunState &state)
 {
-    JS_ASSERT(ion::IsEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
 
     JSScript *script = state.script();
 
     // Skip if the script has been disabled.
     if (!script->canIonCompile())
         return Method_Skipped;
 
     // Skip if the script is being compiled off thread.
@@ -1702,17 +1702,17 @@ ion::CanEnter(JSContext *cx, RunState &s
             ForbidCompilation(cx, script);
             return Method_CantCompile;
         }
 
         if (invoke.constructing() && invoke.args().thisv().isPrimitive()) {
             RootedScript scriptRoot(cx, script);
             RootedObject callee(cx, &invoke.args().callee());
             RootedObject obj(cx, CreateThisForFunction(cx, callee, invoke.useNewType()));
-            if (!obj || !ion::IsEnabled(cx)) // Note: OOM under CreateThis can disable TI.
+            if (!obj || !jit::IsIonEnabled(cx)) // Note: OOM under CreateThis can disable TI.
                 return Method_Skipped;
             invoke.args().setThis(ObjectValue(*obj));
             script = scriptRoot;
         }
     } else if (state.isGenerator()) {
         IonSpew(IonSpew_Abort, "generator frame");
         ForbidCompilation(cx, script);
         return Method_CantCompile;
@@ -1735,20 +1735,20 @@ ion::CanEnter(JSContext *cx, RunState &s
             ForbidCompilation(cx, rscript);
         return status;
     }
 
     return Method_Compiled;
 }
 
 MethodStatus
-ion::CompileFunctionForBaseline(JSContext *cx, HandleScript script, BaselineFrame *frame,
+jit::CompileFunctionForBaseline(JSContext *cx, HandleScript script, BaselineFrame *frame,
                                 bool isConstructing)
 {
-    JS_ASSERT(ion::IsEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
     JS_ASSERT(frame->fun()->nonLazyScript()->canIonCompile());
     JS_ASSERT(!frame->fun()->nonLazyScript()->isIonCompilingOffThread());
     JS_ASSERT(!frame->fun()->nonLazyScript()->hasIonScript());
     JS_ASSERT(frame->isFunctionFrame());
 
     // Mark as forbidden if frame can't be handled.
     if (!CheckFrame(frame)) {
         ForbidCompilation(cx, script);
@@ -1762,17 +1762,17 @@ ion::CompileFunctionForBaseline(JSContex
             ForbidCompilation(cx, script);
         return status;
     }
 
     return Method_Compiled;
 }
 
 MethodStatus
-ion::CanEnterInParallel(JSContext *cx, HandleScript script)
+jit::CanEnterInParallel(JSContext *cx, HandleScript script)
 {
     // Skip if the script has been disabled.
     //
     // Note: We return Method_Skipped in this case because the other
     // CanEnter() methods do so. However, ForkJoin.cpp detects this
     // condition differently treats it more like an error.
     if (!script->canParallelIonCompile())
         return Method_Skipped;
@@ -1805,19 +1805,19 @@ ion::CanEnterInParallel(JSContext *cx, H
             script.get(), script->filename(), script->lineno);
         return Method_Skipped;
     }
 
     return Method_Compiled;
 }
 
 MethodStatus
-ion::CanEnterUsingFastInvoke(JSContext *cx, HandleScript script, uint32_t numActualArgs)
+jit::CanEnterUsingFastInvoke(JSContext *cx, HandleScript script, uint32_t numActualArgs)
 {
-    JS_ASSERT(ion::IsEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
 
     // Skip if the code is expected to result in a bailout.
     if (!script->hasIonScript() || script->ionScript()->bailoutExpected())
         return Method_Skipped;
 
     // Don't handle arguments underflow, to make this work we would have to pad
     // missing arguments with |undefined|.
     if (numActualArgs < script->function()->nargs)
@@ -1835,17 +1835,17 @@ ion::CanEnterUsingFastInvoke(JSContext *
 
     return Method_Compiled;
 }
 
 static IonExecStatus
 EnterIon(JSContext *cx, EnterJitData &data)
 {
     JS_CHECK_RECURSION(cx, return IonExec_Aborted);
-    JS_ASSERT(ion::IsEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
     JS_ASSERT(!data.osrFrame);
 
     EnterIonCode enter = cx->runtime()->ionRuntime()->enterIon();
 
     // Caller must construct |this| before invoking the Ion function.
     JS_ASSERT_IF(data.constructing, data.maxArgv[0].isObject());
 
     data.result.setInt32(data.numActualArgs);
@@ -1870,17 +1870,17 @@ EnterIon(JSContext *cx, EnterJitData &da
     // Release temporary buffer used for OSR into Ion.
     cx->runtime()->getIonRuntime(cx)->freeOsrTempData();
 
     JS_ASSERT_IF(data.result.isMagic(), data.result.isMagic(JS_ION_ERROR));
     return data.result.isMagic() ? IonExec_Error : IonExec_Ok;
 }
 
 bool
-ion::SetEnterJitData(JSContext *cx, EnterJitData &data, RunState &state, AutoValueVector &vals)
+jit::SetEnterJitData(JSContext *cx, EnterJitData &data, RunState &state, AutoValueVector &vals)
 {
     data.osrFrame = NULL;
 
     if (state.isInvoke()) {
         CallArgs &args = state.asInvoke()->args();
         unsigned numFormals = state.script()->function()->nargs;
         data.constructing = state.asInvoke()->constructing();
         data.numActualArgs = args.length();
@@ -1922,17 +1922,17 @@ ion::SetEnterJitData(JSContext *cx, Ente
                 data.calleeToken = CalleeToToken(iter.callee());
         }
     }
 
     return true;
 }
 
 IonExecStatus
-ion::Cannon(JSContext *cx, RunState &state)
+jit::Cannon(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))
@@ -1942,25 +1942,25 @@ ion::Cannon(JSContext *cx, RunState &sta
 
     if (status == IonExec_Ok)
         state.setReturnValue(data.result);
 
     return status;
 }
 
 IonExecStatus
-ion::FastInvoke(JSContext *cx, HandleFunction fun, CallArgs &args)
+jit::FastInvoke(JSContext *cx, HandleFunction fun, CallArgs &args)
 {
     JS_CHECK_RECURSION(cx, return IonExec_Error);
 
     IonScript *ion = fun->nonLazyScript()->ionScript();
     IonCode *code = ion->method();
     void *jitcode = code->raw();
 
-    JS_ASSERT(ion::IsEnabled(cx));
+    JS_ASSERT(jit::IsIonEnabled(cx));
     JS_ASSERT(!ion->bailoutExpected());
 
     JitActivation activation(cx, /* firstFrameIsConstructing = */false);
 
     EnterIonCode enter = cx->runtime()->ionRuntime()->enterIon();
     void *calleeToken = CalleeToToken(fun);
 
     RootedValue result(cx, Int32Value(args.length()));
@@ -2099,17 +2099,17 @@ InvalidateActivation(FreeOp *fop, uint8_
                 ionScript, ionScript->refcount(), (void *) osiPatchPoint.raw());
         Assembler::patchWrite_NearCall(osiPatchPoint, invalidateEpilogue);
     }
 
     IonSpew(IonSpew_Invalidate, "END invalidating activation");
 }
 
 void
-ion::InvalidateAll(FreeOp *fop, Zone *zone)
+jit::InvalidateAll(FreeOp *fop, Zone *zone)
 {
     for (CompartmentsInZoneIter comp(zone); !comp.done(); comp.next()) {
         if (!comp->ionCompartment())
             continue;
         CancelOffThreadIonCompile(comp, NULL);
         FinishAllOffThreadCompilations(comp->ionCompartment());
     }
 
@@ -2120,17 +2120,17 @@ ion::InvalidateAll(FreeOp *fop, Zone *zo
             IonSpew(IonSpew_Invalidate, "Invalidating all frames for GC");
             InvalidateActivation(fop, iter.jitTop(), true);
         }
     }
 }
 
 
 void
-ion::Invalidate(types::TypeCompartment &types, FreeOp *fop,
+jit::Invalidate(types::TypeCompartment &types, FreeOp *fop,
                 const Vector<types::RecompileInfo> &invalid, bool resetUses)
 {
     IonSpew(IonSpew_Invalidate, "Start invalidation.");
     AutoFlushCache afc ("Invalidate");
 
     // Add an invalidation reference to all invalidated IonScripts to indicate
     // to the traversal which frames have been invalidated.
     bool anyInvalidation = false;
@@ -2202,23 +2202,23 @@ ion::Invalidate(types::TypeCompartment &
         //     closure of potential callees, to avoid compiling things
         //     that are never run at all).
         if (resetUses && executionMode != ParallelExecution)
             script->resetUseCount();
     }
 }
 
 void
-ion::Invalidate(JSContext *cx, const Vector<types::RecompileInfo> &invalid, bool resetUses)
+jit::Invalidate(JSContext *cx, const Vector<types::RecompileInfo> &invalid, bool resetUses)
 {
-    ion::Invalidate(cx->compartment()->types, cx->runtime()->defaultFreeOp(), invalid, resetUses);
+    jit::Invalidate(cx->compartment()->types, cx->runtime()->defaultFreeOp(), invalid, resetUses);
 }
 
 bool
-ion::Invalidate(JSContext *cx, JSScript *script, ExecutionMode mode, bool resetUses)
+jit::Invalidate(JSContext *cx, JSScript *script, ExecutionMode mode, bool resetUses)
 {
     JS_ASSERT(script->hasIonScript());
 
     Vector<types::RecompileInfo> scripts(cx);
 
     switch (mode) {
       case SequentialExecution:
         JS_ASSERT(script->hasIonScript());
@@ -2232,71 +2232,71 @@ ion::Invalidate(JSContext *cx, JSScript 
         break;
     }
 
     Invalidate(cx, scripts, resetUses);
     return true;
 }
 
 bool
-ion::Invalidate(JSContext *cx, JSScript *script, bool resetUses)
+jit::Invalidate(JSContext *cx, JSScript *script, bool resetUses)
 {
     return Invalidate(cx, script, SequentialExecution, resetUses);
 }
 
 static void
 FinishInvalidationOf(FreeOp *fop, JSScript *script, IonScript *ionScript, bool parallel)
 {
     // If this script has Ion code on the stack, invalidation() will return
     // true. In this case we have to wait until destroying it.
     if (!ionScript->invalidated()) {
         types::TypeCompartment &types = script->compartment()->types;
         ionScript->recompileInfo().compilerOutput(types)->invalidate();
 
-        ion::IonScript::Destroy(fop, ionScript);
+        jit::IonScript::Destroy(fop, ionScript);
     }
 
     // In all cases, NULL out script->ion or script->parallelIon to avoid
     // re-entry.
     if (parallel)
         script->setParallelIonScript(NULL);
     else
         script->setIonScript(NULL);
 }
 
 void
-ion::FinishInvalidation(FreeOp *fop, JSScript *script)
+jit::FinishInvalidation(FreeOp *fop, JSScript *script)
 {
     if (script->hasIonScript())
         FinishInvalidationOf(fop, script, script->ionScript(), false);
 
     if (script->hasParallelIonScript())
         FinishInvalidationOf(fop, script, script->parallelIonScript(), true);
 }
 
 void
-ion::MarkValueFromIon(JSRuntime *rt, Value *vp)
+jit::MarkValueFromIon(JSRuntime *rt, Value *vp)
 {
     gc::MarkValueUnbarriered(&rt->gcMarker, vp, "write barrier");
 }
 
 void
-ion::MarkShapeFromIon(JSRuntime *rt, Shape **shapep)
+jit::MarkShapeFromIon(JSRuntime *rt, Shape **shapep)
 {
     gc::MarkShapeUnbarriered(&rt->gcMarker, shapep, "write barrier");
 }
 
 void
-ion::ForbidCompilation(JSContext *cx, JSScript *script)
+jit::ForbidCompilation(JSContext *cx, JSScript *script)
 {
     ForbidCompilation(cx, script, SequentialExecution);
 }
 
 void
-ion::ForbidCompilation(JSContext *cx, JSScript *script, ExecutionMode mode)
+jit::ForbidCompilation(JSContext *cx, JSScript *script, ExecutionMode mode)
 {
     IonSpew(IonSpew_Abort, "Disabling Ion mode %d compilation of script %s:%d",
             mode, script->filename(), script->lineno);
 
     CancelOffThreadIonCompile(cx->compartment(), script);
 
     switch (mode) {
       case SequentialExecution:
@@ -2322,17 +2322,17 @@ ion::ForbidCompilation(JSContext *cx, JS
         script->setParallelIonScript(ION_DISABLED_SCRIPT);
         return;
     }
 
     MOZ_ASSUME_UNREACHABLE("No such execution mode");
 }
 
 uint32_t
-ion::UsesBeforeIonRecompile(JSScript *script, jsbytecode *pc)
+jit::UsesBeforeIonRecompile(JSScript *script, jsbytecode *pc)
 {
     JS_ASSERT(pc == script->code || JSOp(*pc) == JSOP_LOOPENTRY);
 
     uint32_t minUses = js_IonOptions.usesBeforeCompile;
 
     // If the script is too large to compile on the main thread, we can still
     // compile it off thread. In these cases, increase the use count threshold
     // to improve the compilation's type information and hopefully avoid later
@@ -2409,56 +2409,56 @@ AutoFlushInhibitor::~AutoFlushInhibitor(
     JS_ASSERT(ic_->flusher() == NULL);
     // Ensure any future modifications are recorded
     ic_->setFlusher(afc);
     if (afc)
         IonSpewCont(IonSpew_CacheFlush, "{");
 }
 
 void
-ion::PurgeCaches(JSScript *script, Zone *zone)
+jit::PurgeCaches(JSScript *script, Zone *zone)
 {
     if (script->hasIonScript())
         script->ionScript()->purgeCaches(zone);
 
     if (script->hasParallelIonScript())
         script->parallelIonScript()->purgeCaches(zone);
 }
 
 size_t
-ion::SizeOfIonData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf)
+jit::SizeOfIonData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf)
 {
     size_t result = 0;
 
     if (script->hasIonScript())
         result += script->ionScript()->sizeOfIncludingThis(mallocSizeOf);
 
     if (script->hasParallelIonScript())
         result += script->parallelIonScript()->sizeOfIncludingThis(mallocSizeOf);
 
     return result;
 }
 
 void
-ion::DestroyIonScripts(FreeOp *fop, JSScript *script)
+jit::DestroyIonScripts(FreeOp *fop, JSScript *script)
 {
     if (script->hasIonScript())
-        ion::IonScript::Destroy(fop, script->ionScript());
+        jit::IonScript::Destroy(fop, script->ionScript());
 
     if (script->hasParallelIonScript())
-        ion::IonScript::Destroy(fop, script->parallelIonScript());
+        jit::IonScript::Destroy(fop, script->parallelIonScript());
 
     if (script->hasBaselineScript())
-        ion::BaselineScript::Destroy(fop, script->baselineScript());
+        jit::BaselineScript::Destroy(fop, script->baselineScript());
 }
 
 void
-ion::TraceIonScripts(JSTracer* trc, JSScript *script)
+jit::TraceIonScripts(JSTracer* trc, JSScript *script)
 {
     if (script->hasIonScript())
-        ion::IonScript::Trace(trc, script->ionScript());
+        jit::IonScript::Trace(trc, script->ionScript());
 
     if (script->hasParallelIonScript())
-        ion::IonScript::Trace(trc, script->parallelIonScript());
+        jit::IonScript::Trace(trc, script->parallelIonScript());
 
     if (script->hasBaselineScript())
-        ion::BaselineScript::Trace(trc, script->baselineScript());
+        jit::BaselineScript::Trace(trc, script->baselineScript());
 }
--- a/js/src/jit/Ion.h
+++ b/js/src/jit/Ion.h
@@ -15,17 +15,17 @@
 #include "jscompartment.h"
 #include "jsinfer.h"
 
 #include "jit/CompileInfo.h"
 #include "jit/IonCode.h"
 #include "vm/Interpreter.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class TempAllocator;
 
 // Possible register allocators which may be used.
 enum IonRegisterAllocator {
     RegisterAllocator_LSRA,
     RegisterAllocator_Backtracking,
     RegisterAllocator_Stupid
@@ -334,17 +334,17 @@ bool OptimizeMIR(MIRGenerator *mir);
 LIRGraph *GenerateLIR(MIRGenerator *mir);
 CodeGenerator *GenerateCode(MIRGenerator *mir, LIRGraph *lir, MacroAssembler *maybeMasm = NULL);
 CodeGenerator *CompileBackEnd(MIRGenerator *mir, MacroAssembler *maybeMasm = NULL);
 
 void AttachFinishedCompilations(JSContext *cx);
 void FinishOffThreadBuilder(IonBuilder *builder);
 
 static inline bool
-IsEnabled(JSContext *cx)
+IsIonEnabled(JSContext *cx)
 {
     return cx->hasOption(JSOPTION_ION) &&
         cx->hasOption(JSOPTION_BASELINE) &&
         cx->typeInferenceEnabled();
 }
 
 inline bool
 IsIonInlinablePC(jsbytecode *pc) {
@@ -358,14 +358,14 @@ void ForbidCompilation(JSContext *cx, JS
 void ForbidCompilation(JSContext *cx, JSScript *script, ExecutionMode mode);
 uint32_t UsesBeforeIonRecompile(JSScript *script, jsbytecode *pc);
 
 void PurgeCaches(JSScript *script, JS::Zone *zone);
 size_t SizeOfIonData(JSScript *script, mozilla::MallocSizeOf mallocSizeOf);
 void DestroyIonScripts(FreeOp *fop, JSScript *script);
 void TraceIonScripts(JSTracer* trc, JSScript *script);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_Ion_h */
--- a/js/src/jit/IonAllocPolicy.h
+++ b/js/src/jit/IonAllocPolicy.h
@@ -11,17 +11,17 @@
 
 #include "jscntxt.h"
 
 #include "ds/LifoAlloc.h"
 #include "jit/InlineList.h"
 #include "jit/Ion.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class TempAllocator
 {
     LifoAllocScope lifoScope_;
 
     // Linked list of GCThings rooted by this allocator.
     CompilerRootNode *rootList_;
 
@@ -153,12 +153,12 @@ class TempObjectPool
     void free(T *obj) {
         freed_.pushFront(obj);
     }
     void clear() {
         freed_.clear();
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_IonAllocPolicy_h */
--- a/js/src/jit/IonAnalysis.cpp
+++ b/js/src/jit/IonAnalysis.cpp
@@ -9,23 +9,23 @@
 #include "jsanalyze.h"
 
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/LIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // A critical edge is an edge which is neither its successor's only predecessor
 // nor its predecessor's only successor. Critical edges must be split to
 // prevent copy-insertion and code motion from affecting other edges.
 bool
-ion::SplitCriticalEdges(MIRGraph &graph)
+jit::SplitCriticalEdges(MIRGraph &graph)
 {
     for (MBasicBlockIterator block(graph.begin()); block != graph.end(); block++) {
         if (block->numSuccessors() < 2)
             continue;
         for (size_t i = 0; i < block->numSuccessors(); i++) {
             MBasicBlock *target = block->getSuccessor(i);
             if (target->numPredecessors() < 2)
                 continue;
@@ -49,17 +49,17 @@ ion::SplitCriticalEdges(MIRGraph &graph)
 // block and have no uses outside the block or at points later than the resume
 // point.
 //
 // This is intended to ensure that extra resume points within a basic block
 // will not artificially extend the lifetimes of any SSA values. This could
 // otherwise occur if the new resume point captured a value which is created
 // between the old and new resume point and is dead at the new resume point.
 bool
-ion::EliminateDeadResumePointOperands(MIRGenerator *mir, MIRGraph &graph)
+jit::EliminateDeadResumePointOperands(MIRGenerator *mir, MIRGraph &graph)
 {
     for (PostorderIterator block = graph.poBegin(); block != graph.poEnd(); block++) {
         if (mir->shouldCancel("Eliminate Dead Resume Point Operands (main loop)"))
             return false;
 
         // The logic below can get confused on infinite loops.
         if (block->isLoopHeader() && block->backedge() == *block)
             continue;
@@ -137,17 +137,17 @@ ion::EliminateDeadResumePointOperands(MI
 
     return true;
 }
 
 // Instructions are useless if they are unused and have no side effects.
 // This pass eliminates useless instructions.
 // The graph itself is unchanged.
 bool
-ion::EliminateDeadCode(MIRGenerator *mir, MIRGraph &graph)
+jit::EliminateDeadCode(MIRGenerator *mir, MIRGraph &graph)
 {
     // Traverse in postorder so that we hit uses before definitions.
     // Traverse instruction list backwards for the same reason.
     for (PostorderIterator block = graph.poBegin(); block != graph.poEnd(); block++) {
         if (mir->shouldCancel("Eliminate Dead Code (main loop)"))
             return false;
 
         // Remove unused instructions.
@@ -232,17 +232,17 @@ IsPhiRedundant(MPhi *phi)
     // Propagate the Folded flag if |phi| is replaced with another phi.
     if (phi->isFolded())
         first->setFoldedUnchecked();
 
     return first;
 }
 
 bool
-ion::EliminatePhis(MIRGenerator *mir, MIRGraph &graph,
+jit::EliminatePhis(MIRGenerator *mir, MIRGraph &graph,
                    Observability observe)
 {
     // Eliminates redundant or unobservable phis from the graph.  A
     // redundant phi is something like b = phi(a, a) or b = phi(a, b),
     // both of which can be replaced with a.  An unobservable phi is
     // one that whose value is never used in the program.
     //
     // Note that we must be careful not to eliminate phis representing
@@ -640,28 +640,28 @@ TypeAnalyzer::analyze()
     if (!specializePhis())
         return false;
     if (!insertConversions())
         return false;
     return true;
 }
 
 bool
-ion::ApplyTypeInformation(MIRGenerator *mir, MIRGraph &graph)
+jit::ApplyTypeInformation(MIRGenerator *mir, MIRGraph &graph)
 {
     TypeAnalyzer analyzer(mir, graph);
 
     if (!analyzer.analyze())
         return false;
 
     return true;
 }
 
 bool
-ion::RenumberBlocks(MIRGraph &graph)
+jit::RenumberBlocks(MIRGraph &graph)
 {
     size_t id = 0;
     for (ReversePostorderIterator block(graph.rpoBegin()); block != graph.rpoEnd(); block++)
         block->setId(id++);
 
     return true;
 }
 
@@ -757,17 +757,17 @@ ComputeImmediateDominators(MIRGraph &gra
     // Assert that all blocks have dominator information.
     for (MBasicBlockIterator block(graph.begin()); block != graph.end(); block++) {
         JS_ASSERT(block->immediateDominator() != NULL);
     }
 #endif
 }
 
 bool
-ion::BuildDominatorTree(MIRGraph &graph)
+jit::BuildDominatorTree(MIRGraph &graph)
 {
     ComputeImmediateDominators(graph);
 
     // Traversing through the graph in post-order means that every 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.
@@ -820,17 +820,17 @@ ion::BuildDominatorTree(MIRGraph &graph)
         }
         index++;
     }
 
     return true;
 }
 
 bool
-ion::BuildPhiReverseMapping(MIRGraph &graph)
+jit::BuildPhiReverseMapping(MIRGraph &graph)
 {
     // Build a mapping such that given a basic block, whose successor has one or
     // more phis, we can find our specific input to that phi. To make this fast
     // mapping work we rely on a specific property of our structured control
     // flow graph: For a block with phis, its predecessors each have only one
     // successor with phis. Consider each case:
     //   * Blocks with less than two predecessors cannot have phis.
     //   * Breaks. A break always has exactly one successor, and the break
@@ -932,17 +932,17 @@ CheckUseImpliesOperand(MInstruction *ins
 
     JS_ASSERT(consumer->isResumePoint());
     MResumePoint *res = consumer->toResumePoint();
     return (res->getOperand(index) == ins);
 }
 #endif // DEBUG
 
 void
-ion::AssertBasicGraphCoherency(MIRGraph &graph)
+jit::AssertBasicGraphCoherency(MIRGraph &graph)
 {
 #ifdef DEBUG
     // Assert successor and predecessor list coherency.
     uint32_t count = 0;
     for (MBasicBlockIterator block(graph.begin()); block != graph.end(); block++) {
         count++;
 
         for (size_t i = 0; i < block->numSuccessors(); i++)
@@ -982,26 +982,26 @@ AssertReversePostOrder(MIRGraph &graph)
         block->mark();
     }
 
     graph.unmarkBlocks();
 }
 #endif
 
 void
-ion::AssertGraphCoherency(MIRGraph &graph)
+jit::AssertGraphCoherency(MIRGraph &graph)
 {
 #ifdef DEBUG
     AssertBasicGraphCoherency(graph);
     AssertReversePostOrder(graph);
 #endif
 }
 
 void
-ion::AssertExtendedGraphCoherency(MIRGraph &graph)
+jit::AssertExtendedGraphCoherency(MIRGraph &graph)
 {
     // Checks the basic GraphCoherency but also other conditions that
     // do not hold immediately (such as the fact that critical edges
     // are split)
 
 #ifdef DEBUG
     AssertGraphCoherency(graph);
 
@@ -1087,17 +1087,17 @@ FindDominatingBoundsCheck(BoundsCheckMap
         return check;
     }
 
     return p->value.check;
 }
 
 // Extract a linear sum from ins, if possible (otherwise giving the sum 'ins + 0').
 SimpleLinearSum
-ion::ExtractLinearSum(MDefinition *ins)
+jit::ExtractLinearSum(MDefinition *ins)
 {
     if (ins->isBeta())
         ins = ins->getOperand(0);
 
     if (ins->type() != MIRType_Int32)
         return SimpleLinearSum(ins, 0);
 
     if (ins->isConstant()) {
@@ -1130,17 +1130,17 @@ ion::ExtractLinearSum(MDefinition *ins)
     }
 
     return SimpleLinearSum(ins, 0);
 }
 
 // Extract a linear inequality holding when a boolean test goes in the
 // specified direction, of the form 'lhs + lhsN <= rhs' (or >=).
 bool
-ion::ExtractLinearInequality(MTest *test, BranchDirection direction,
+jit::ExtractLinearInequality(MTest *test, BranchDirection direction,
                              SimpleLinearSum *plhs, MDefinition **prhs, bool *plessEqual)
 {
     if (!test->getOperand(0)->isCompare())
         return false;
 
     MCompare *compare = test->getOperand(0)->toCompare();
 
     MDefinition *lhs = compare->getOperand(0);
@@ -1353,17 +1353,17 @@ TryEliminateTypeBarrier(MTypeBarrier *ba
 // check with the same length and the indexes differ by only a constant amount.
 // In this case we eliminate the redundant bounds check and update the other one
 // to cover the ranges of both checks.
 //
 // Bounds checks are added to a hash map and since the hash function ignores
 // differences in constant offset, this offers a fast way to find redundant
 // checks.
 bool
-ion::EliminateRedundantChecks(MIRGraph &graph)
+jit::EliminateRedundantChecks(MIRGraph &graph)
 {
     BoundsCheckMap checks;
 
     if (!checks.init())
         return false;
 
     // Stack for pre-order CFG traversal.
     Vector<MBasicBlock *, 1, IonAllocPolicy> worklist;
@@ -1439,17 +1439,17 @@ FindLeadingGoto(LBlock *bb)
     return NULL;
 }
 
 // Eliminate blocks containing nothing interesting besides gotos. These are
 // often created by optimizer, which splits all critical edges. If these
 // splits end up being unused after optimization and register allocation,
 // fold them back away to avoid unnecessary branching.
 bool
-ion::UnsplitEdges(LIRGraph *lir)
+jit::UnsplitEdges(LIRGraph *lir)
 {
     for (size_t i = 0; i < lir->numBlocks(); i++) {
         LBlock *bb = lir->getBlock(i);
         MBasicBlock *mirBlock = bb->mir();
 
         // Renumber the MIR blocks as we go, since we may remove some.
         mirBlock->setId(i);
 
--- a/js/src/jit/IonAnalysis.h
+++ b/js/src/jit/IonAnalysis.h
@@ -8,17 +8,17 @@
 #define jit_IonAnalysis_h
 
 // This file declares various analysis passes that operate on MIR.
 
 #include "jit/IonAllocPolicy.h"
 #include "jit/MIR.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MIRGenerator;
 class MIRGraph;
 
 bool
 SplitCriticalEdges(MIRGraph &graph);
 
 enum Observability {
@@ -119,12 +119,12 @@ class LinearSum
 
     void print(Sprinter &sp) const;
 
   private:
     Vector<LinearTerm, 2, IonAllocPolicy> terms_;
     int32_t constant_;
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_IonAnalysis_h */
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -21,17 +21,17 @@
 
 #include "jsinferinlines.h"
 #include "jsobjinlines.h"
 #include "jsscriptinlines.h"
 
 #include "jit/CompileInfo-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 IonBuilder::IonBuilder(JSContext *cx, TempAllocator *temp, MIRGraph *graph,
                        BaselineInspector *inspector, CompileInfo *info, BaselineFrame *baselineFrame,
                        size_t inliningDepth, uint32_t loopDepth)
   : MIRGenerator(cx->compartment(), temp, graph, info),
     backgroundCodegen_(NULL),
@@ -6135,17 +6135,17 @@ IonBuilder::getStaticName(HandleObject s
     if (barrier)
         rvalType = MIRType_Value;
 
     return loadSlot(obj, shape, rvalType, barrier, types);
 }
 
 // Whether 'types' includes all possible values represented by input/inputTypes.
 bool
-ion::TypeSetIncludes(types::TypeSet *types, MIRType input, types::TypeSet *inputTypes)
+jit::TypeSetIncludes(types::TypeSet *types, MIRType input, types::TypeSet *inputTypes)
 {
     switch (input) {
       case MIRType_Undefined:
       case MIRType_Null:
       case MIRType_Boolean:
       case MIRType_Int32:
       case MIRType_Double:
       case MIRType_String:
@@ -6160,17 +6160,17 @@ ion::TypeSetIncludes(types::TypeSet *typ
 
       default:
         MOZ_ASSUME_UNREACHABLE("Bad input type");
     }
 }
 
 // Whether a write of the given value may need a post-write barrier for GC purposes.
 bool
-ion::NeedsPostBarrier(CompileInfo &info, MDefinition *value)
+jit::NeedsPostBarrier(CompileInfo &info, MDefinition *value)
 {
     return info.executionMode() != ParallelExecution && value->mightBeType(MIRType_Object);
 }
 
 bool
 IonBuilder::setStaticName(HandleObject staticObject, HandlePropertyName name)
 {
     RootedId id(cx, NameToId(name));
--- a/js/src/jit/IonBuilder.h
+++ b/js/src/jit/IonBuilder.h
@@ -11,17 +11,17 @@
 
 // This file declares the data structures for building a MIRGraph from a
 // JSScript.
 
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class CodeGenerator;
 class CallInfo;
 class BaselineInspector;
 
 class IonBuilder : public MIRGenerator
 {
     enum ControlStatus {
@@ -816,14 +816,14 @@ class CallInfo
         return passArg;
     }
 };
 
 bool TypeSetIncludes(types::TypeSet *types, MIRType input, types::TypeSet *inputTypes);
 
 bool NeedsPostBarrier(CompileInfo &info, MDefinition *value);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_IonBuilder_h */
--- a/js/src/jit/IonCaches.cpp
+++ b/js/src/jit/IonCaches.cpp
@@ -14,17 +14,17 @@
 #include "jit/IonSpewer.h"
 #include "jit/PerfSpewer.h"
 #include "jit/VMFunctions.h"
 #include "vm/Shape.h"
 
 #include "vm/Interpreter-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 void
 CodeLocationJump::repoint(IonCode *code, MacroAssembler *masm)
 {
     JS_ASSERT(state_ == Relative);
     size_t new_off = (size_t)raw_;
--- a/js/src/jit/IonCaches.h
+++ b/js/src/jit/IonCaches.h
@@ -17,17 +17,17 @@
 
 class JSFunction;
 class JSScript;
 
 namespace js {
 
 class TypedArrayObject;
 
-namespace ion {
+namespace jit {
 
 #define IONCACHE_KIND_LIST(_)                                   \
     _(GetProperty)                                              \
     _(SetProperty)                                              \
     _(GetElement)                                               \
     _(SetElement)                                               \
     _(BindName)                                                 \
     _(Name)                                                     \
@@ -1020,12 +1020,12 @@ class GetElementParIC : public ParallelI
     ickind##IC &IonCache::to##ickind()                                  \
     {                                                                   \
         JS_ASSERT(is##ickind());                                        \
         return *static_cast<ickind##IC *>(this);                        \
     }
 IONCACHE_KIND_LIST(CACHE_CASTS)
 #undef OPCODE_CASTS
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_IonCaches_h */
--- a/js/src/jit/IonCode.h
+++ b/js/src/jit/IonCode.h
@@ -20,17 +20,17 @@ namespace JSC {
 }
 
 class JSScript;
 
 namespace js {
 
 class AsmJSModule;
 
-namespace ion {
+namespace jit {
 
 // The maximum size of any buffer associated with an assembler or code object.
 // This is chosen to not overflow a signed integer, leaving room for an extra
 // bit on offsets.
 static const uint32_t MAX_BUFFER_SIZE = (1 << 30) - 1;
 
 // Maximum number of scripted arg slots.
 static const uint32_t SNAPSHOT_MAX_NARGS = 127;
@@ -718,22 +718,22 @@ struct AutoFlushCache
 struct AutoFlushInhibitor {
   private:
     IonCompartment *ic_;
     AutoFlushCache *afc;
   public:
     AutoFlushInhibitor(IonCompartment *ic);
     ~AutoFlushInhibitor();
 };
-} // namespace ion
+} // namespace jit
 
 namespace gc {
 
 inline bool
-IsMarked(const ion::VMFunction *)
+IsMarked(const jit::VMFunction *)
 {
     // VMFunction are only static objects which are used by WeakMaps as keys.
     // It is considered as a root object which is always marked.
     return true;
 }
 
 } // namespace gc
 
--- a/js/src/jit/IonCompartment.h
+++ b/js/src/jit/IonCompartment.h
@@ -15,17 +15,17 @@
 
 #include "jit/CompileInfo.h"
 #include "jit/IonCode.h"
 #include "jit/IonFrames.h"
 #include "js/Value.h"
 #include "vm/Stack.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class FrameSizeClass;
 
 enum EnterJitType {
     EnterJitBaseline = 0,
     EnterJitOptimized = 1
 };
 
@@ -370,14 +370,14 @@ class IonCompartment
         return &optimizedStubSpace_;
     }
 };
 
 // Called from JSCompartment::discardJitCode().
 void InvalidateAll(FreeOp *fop, JS::Zone *zone);
 void FinishInvalidation(FreeOp *fop, JSScript *script);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_IonCompartment_h */
--- a/js/src/jit/IonFrameIterator-inl.h
+++ b/js/src/jit/IonFrameIterator-inl.h
@@ -10,17 +10,17 @@
 #ifdef JS_ION
 
 #include "jit/IonFrameIterator.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 template <AllowGC allowGC>
 inline
 InlineFrameIteratorMaybeGC<allowGC>::InlineFrameIteratorMaybeGC(
                                                 JSContext *cx, const IonBailoutIterator *iter)
   : frame_(iter),
     framesRead_(0),
     callee_(cx),
@@ -34,14 +34,14 @@ InlineFrameIteratorMaybeGC<allowGC>::Inl
 
 inline BaselineFrame *
 IonFrameIterator::baselineFrame() const
 {
     JS_ASSERT(isBaselineJS());
     return (BaselineFrame *)(fp() - BaselineFrame::FramePointerOffset - BaselineFrame::Size());
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_IonFrameIterator_inl_h */
--- a/js/src/jit/IonFrameIterator.h
+++ b/js/src/jit/IonFrameIterator.h
@@ -15,17 +15,17 @@
 #include "jit/IonCode.h"
 #include "jit/SnapshotReader.h"
 
 namespace js {
     class ActivationIterator;
 };
 
 namespace js {
-namespace ion {
+namespace jit {
 
 enum FrameType
 {
     // A JS frame is analagous to a js::StackFrame, representing one scripted
     // functon activation. OptimizedJS frames are used by the optimizing compiler.
     IonFrame_OptimizedJS,
 
     // JS frame used by the baseline JIT.
@@ -482,14 +482,14 @@ class InlineFrameIteratorMaybeGC
 
   private:
     InlineFrameIteratorMaybeGC() MOZ_DELETE;
     InlineFrameIteratorMaybeGC(const InlineFrameIteratorMaybeGC &iter) MOZ_DELETE;
 };
 typedef InlineFrameIteratorMaybeGC<CanGC> InlineFrameIterator;
 typedef InlineFrameIteratorMaybeGC<NoGC> InlineFrameIteratorNoGC;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_IonFrameIterator_h */
--- a/js/src/jit/IonFrames-inl.h
+++ b/js/src/jit/IonFrames-inl.h
@@ -12,17 +12,17 @@
 #include "jit/IonFrames.h"
 
 #include "jit/IonFrameIterator.h"
 #include "jit/LIR.h"
 
 #include "jit/IonFrameIterator-inl.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 inline void
 SafepointIndex::resolve()
 {
     JS_ASSERT(!resolved);
     safepointOffset_ = safepoint_->offset();
     resolved = true;
 }
@@ -73,14 +73,14 @@ GetTopBaselineFrame(JSContext *cx)
     JS_ASSERT(iter.type() == IonFrame_Exit);
     ++iter;
     if (iter.isBaselineStub())
         ++iter;
     JS_ASSERT(iter.isBaselineJS());
     return iter.baselineFrame();
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_IonFrames_inl_h */
--- a/js/src/jit/IonFrames.cpp
+++ b/js/src/jit/IonFrames.cpp
@@ -24,17 +24,17 @@
 #include "jit/VMFunctions.h"
 
 #include "jsfuninlines.h"
 
 #include "jit/IonFrameIterator-inl.h"
 #include "vm/Probes-inl.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 IonFrameIterator::IonFrameIterator(const ActivationIterator &activations)
     : current_(activations.jitTop()),
       type_(IonFrame_Exit),
       returnAddressToFp_(NULL),
       frameSize_(0),
       cachedSafepointIndex_(NULL),
       activation_(activations.activation()->asJit())
@@ -401,17 +401,17 @@ HandleException(JSContext *cx, const Ion
 
           case JSTRAP_CONTINUE:
           case JSTRAP_THROW:
             JS_ASSERT(cx->isExceptionPending());
             break;
 
           case JSTRAP_RETURN:
             JS_ASSERT(baselineFrame->hasReturnValue());
-            if (ion::DebugEpilogue(cx, baselineFrame, true)) {
+            if (jit::DebugEpilogue(cx, baselineFrame, true)) {
                 rfe->kind = ResumeFromException::RESUME_FORCED_RETURN;
                 rfe->framePointer = frame.fp() - BaselineFrame::FramePointerOffset;
                 rfe->stackPointer = reinterpret_cast<uint8_t *>(baselineFrame);
                 return;
             }
 
             // DebugEpilogue threw an exception. Propagate to the caller frame.
             *calledDebugEpilogue = true;
@@ -547,17 +547,17 @@ HandleException(ResumeFromException *rfe
             // to be.  Unset the flag here so that if we call DebugEpilogue below,
             // it doesn't try to pop the SPS frame again.
             iter.baselineFrame()->unsetPushedSPSFrame();
  
             if (cx->compartment()->debugMode() && !calledDebugEpilogue) {
                 // If DebugEpilogue returns |true|, we have to perform a forced
                 // return, e.g. return frame->returnValue() to the caller.
                 BaselineFrame *frame = iter.baselineFrame();
-                if (ion::DebugEpilogue(cx, frame, false)) {
+                if (jit::DebugEpilogue(cx, frame, false)) {
                     JS_ASSERT(frame->hasReturnValue());
                     rfe->kind = ResumeFromException::RESUME_FORCED_RETURN;
                     rfe->framePointer = iter.fp() - BaselineFrame::FramePointerOffset;
                     rfe->stackPointer = reinterpret_cast<uint8_t *>(frame);
                     return;
                 }
             }
         }
@@ -1621,10 +1621,10 @@ IonFrameIterator::dump() const
         break;
       case IonFrame_Osr:
         fprintf(stderr, "Warning! OSR frame are not defined yet.\n");
         break;
     };
     fputc('\n', stderr);
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/IonFrames.h
+++ b/js/src/jit/IonFrames.h
@@ -19,17 +19,17 @@
 #include "jit/IonCode.h"
 #include "jit/IonFrameIterator.h"
 #include "jit/Registers.h"
 
 class JSFunction;
 class JSScript;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 typedef void * CalleeToken;
 
 enum CalleeTokenTag
 {
     CalleeToken_Function = 0x0, // untagged
     CalleeToken_Script = 0x1,
     CalleeToken_ParallelFunction = 0x2
@@ -98,17 +98,17 @@ ScriptFromCalleeToken(CalleeToken token)
 // In between every two frames lies a small header describing both frames. This
 // header, minimally, contains a returnAddress word and a descriptor word. The
 // descriptor describes the size and type of the previous frame, whereas the
 // returnAddress describes the address the newer frame (the callee) will return
 // to. The exact mechanism in which frames are laid out is architecture
 // dependent.
 //
 // Two special frame types exist. Entry frames begin an ion activation, and
-// therefore there is exactly one per activation of ion::Cannon. Exit frames
+// therefore there is exactly one per activation of jit::Cannon. Exit frames
 // are necessary to leave JIT code and enter C++, and thus, C++ code will
 // always begin iterating from the topmost exit frame.
 
 class LSafepoint;
 
 // Two-tuple that lets you look up the safepoint entry given the
 // displacement of a call instruction within the JIT code.
 class SafepointIndex
@@ -312,29 +312,29 @@ GetTopIonJSScript(PerThreadData *pt, con
 }
 
 inline JSScript *
 GetTopIonJSScript(JSContext *cx, const SafepointIndex **safepointIndexOut, void **returnAddrOut)
 {
     return GetTopIonJSScript(&cx->mainThread(), safepointIndexOut, returnAddrOut);
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #if defined(JS_CPU_X86) || defined (JS_CPU_X64)
 # include "jit/shared/IonFrames-x86-shared.h"
 #elif defined (JS_CPU_ARM)
 # include "jit/arm/IonFrames-arm.h"
 #else
 # error "unsupported architecture"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 JSScript *
 GetTopIonJSScript(JSContext *cx,
                   const SafepointIndex **safepointIndexOut = NULL,
                   void **returnAddrOut = NULL);
 
 void
 GetPcScript(JSContext *cx, JSScript **scriptRes, jsbytecode **pcRes);
@@ -360,14 +360,14 @@ static inline double
 ReadFrameDoubleSlot(IonJSFrameLayout *fp, int32_t slot)
 {
     return *(double *)((char *)fp + OffsetOfFrameSlot(slot));
 }
 
 CalleeToken
 MarkCalleeToken(JSTracer *trc, CalleeToken token);
 
-} /* namespace ion */
+} /* namespace jit */
 } /* namespace js */
 
 #endif // JS_ION
 
 #endif /* jit_IonFrames_h */
--- a/js/src/jit/IonInstrumentation.h
+++ b/js/src/jit/IonInstrumentation.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_IonInstrumentation_h
 #define jit_IonInstrumentation_h
 
 namespace js {
 
 class SPSProfiler;
 
-namespace ion {
+namespace jit {
 
 class MacroAssembler;
 
 typedef SPSInstrumentation<MacroAssembler, Register> BaseInstrumentation;
 
 class IonInstrumentation : public BaseInstrumentation
 {
     jsbytecode **trackedPc_;
@@ -29,12 +29,12 @@ class IonInstrumentation : public BaseIn
         JS_ASSERT(pc != NULL);
     }
 
     void leave(MacroAssembler &masm, Register reg) {
         BaseInstrumentation::leave(*trackedPc_, masm, reg);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_IonInstrumentation_h */
--- a/js/src/jit/IonLinker.h
+++ b/js/src/jit/IonLinker.h
@@ -12,17 +12,17 @@
 #include "jsgc.h"
 
 #include "assembler/jit/ExecutableAllocator.h"
 #include "jit/IonCode.h"
 #include "jit/IonCompartment.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class Linker
 {
     MacroAssembler &masm;
 
     IonCode *fail(JSContext *cx) {
         js_ReportOutOfMemory(cx);
         return NULL;
@@ -73,12 +73,12 @@ class Linker
         masm.finish();
     }
 
     IonCode *newCode(JSContext *cx, JSC::CodeKind kind) {
         return newCode(cx, cx->compartment()->ionCompartment(), kind);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_IonLinker_h */
--- a/js/src/jit/IonMacroAssembler.cpp
+++ b/js/src/jit/IonMacroAssembler.cpp
@@ -18,17 +18,17 @@
 #include "vm/ForkJoin.h"
 
 #include "jsgcinlines.h"
 #include "jsinferinlines.h"
 
 #include "vm/Shape-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // Emulate a TypeSet logic from a Type object to avoid duplicating the guard
 // logic.
 class TypeWrapper {
     types::Type t_;
 
   public:
     TypeWrapper(types::Type t) : t_(t) {}
@@ -1105,20 +1105,20 @@ MacroAssembler::handleFailure(ExecutionM
     // running function and never come back
     if (sps_)
         sps_->skipNextReenter();
     leaveSPSFrame();
 
     void *handler;
     switch (executionMode) {
       case SequentialExecution:
-        handler = JS_FUNC_TO_DATA_PTR(void *, ion::HandleException);
+        handler = JS_FUNC_TO_DATA_PTR(void *, jit::HandleException);
         break;
       case ParallelExecution:
-        handler = JS_FUNC_TO_DATA_PTR(void *, ion::HandleParallelFailure);
+        handler = JS_FUNC_TO_DATA_PTR(void *, jit::HandleParallelFailure);
         break;
       default:
         MOZ_ASSUME_UNREACHABLE("No such execution mode");
     }
     MacroAssemblerSpecific::handleFailureWithHandler(handler);
 
     // Doesn't actually emit code, but balances the leave()
     if (sps_)
--- a/js/src/jit/IonMacroAssembler.h
+++ b/js/src/jit/IonMacroAssembler.h
@@ -23,17 +23,17 @@
 #include "jit/ParallelFunctions.h"
 #include "jit/VMFunctions.h"
 #include "vm/ForkJoin.h"
 #include "vm/ProxyObject.h"
 #include "vm/Shape.h"
 #include "vm/TypedArrayObject.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // The public entrypoint for emitting assembly. Note that a MacroAssembler can
 // use cx->lifoAlloc, so take care not to interleave masm use with other
 // lifoAlloc use if one will be destroyed before the other.
 class MacroAssembler : public MacroAssemblerSpecific
 {
     MacroAssembler *thisFromCtor() {
         return this;
@@ -96,17 +96,17 @@ class MacroAssembler : public MacroAssem
     // This constructor should only be used when there is no IonContext active
     // (for example, Trampoline-$(ARCH).cpp and IonCaches.cpp).
     MacroAssembler(JSContext *cx)
       : enoughMemory_(true),
         embedsNurseryPointers_(false),
         sps_(NULL)
     {
         constructRoot(cx);
-        ionContext_.construct(cx, (js::ion::TempAllocator *)NULL);
+        ionContext_.construct(cx, (js::jit::TempAllocator *)NULL);
         alloc_.construct(cx);
 #ifdef JS_CPU_ARM
         initWithAllocator();
         m_buffer.id = GetIonContext()->getNextAssemblerId();
 #endif
     }
 
     // asm.js compilation handles its own IonContet-pushing
@@ -1024,14 +1024,14 @@ JSOpToCondition(JSOp op, bool isSigned)
           case JSOP_GE:
             return Assembler::AboveOrEqual;
           default:
             MOZ_ASSUME_UNREACHABLE("Unrecognized comparison operation");
         }
     }
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_IonMacroAssembler_h */
--- a/js/src/jit/IonSpewer.cpp
+++ b/js/src/jit/IonSpewer.cpp
@@ -16,17 +16,17 @@
 # elif defined(__ANDROID__)
 #  define ION_SPEW_DIR "/data/local/tmp/"
 # else
 #  define ION_SPEW_DIR "/tmp/"
 # endif
 #endif
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // IonSpewer singleton.
 static IonSpewer ionspewer;
 
 static bool LoggingChecked = false;
 static uint32_t LoggingBits = 0;
 static uint32_t filteredOutCompilations = 0;
 
@@ -65,44 +65,44 @@ FilterContainsLocation(HandleScript func
             }
         }
         index = strstr(index + filelen, filename);
     }
     return false;
 }
 
 void
-ion::EnableIonDebugLogging()
+jit::EnableIonDebugLogging()
 {
     ionspewer.init();
 }
 
 void
-ion::IonSpewNewFunction(MIRGraph *graph, HandleScript function)
+jit::IonSpewNewFunction(MIRGraph *graph, HandleScript function)
 {
     if (!js_IonOptions.parallelCompilation)
         ionspewer.beginFunction(graph, function);
 }
 
 void
-ion::IonSpewPass(const char *pass)
+jit::IonSpewPass(const char *pass)
 {
     if (!js_IonOptions.parallelCompilation)
         ionspewer.spewPass(pass);
 }
 
 void
-ion::IonSpewPass(const char *pass, LinearScanAllocator *ra)
+jit::IonSpewPass(const char *pass, LinearScanAllocator *ra)
 {
     if (!js_IonOptions.parallelCompilation)
         ionspewer.spewPass(pass, ra);
 }
 
 void
-ion::IonSpewEndFunction()
+jit::IonSpewEndFunction()
 {
     if (!js_IonOptions.parallelCompilation)
         ionspewer.endFunction();
 }
 
 
 IonSpewer::~IonSpewer()
 {
@@ -195,33 +195,33 @@ IonSpewer::endFunction()
 
     c1Spewer.endFunction();
     jsonSpewer.endFunction();
 
     this->graph = NULL;
 }
 
 
-FILE *ion::IonSpewFile = NULL;
+FILE *jit::IonSpewFile = NULL;
 
 static bool
 ContainsFlag(const char *str, const char *flag)
 {
     size_t flaglen = strlen(flag);
     const char *index = strstr(str, flag);
     while (index) {
         if ((index == str || index[-1] == ',') && (index[flaglen] == 0 || index[flaglen] == ','))
             return true;
         index = strstr(index + flaglen, flag);
     }
     return false;
 }
 
 void
-ion::CheckLogging()
+jit::CheckLogging()
 {
     if (LoggingChecked)
         return;
     LoggingChecked = true;
     const char *env = getenv("IONFLAGS");
     if (!env)
         return;
     if (strstr(env, "help")) {
@@ -242,17 +242,17 @@ ion::CheckLogging()
             "  codegen    Native code generation\n"
             "  bailouts   Bailouts\n"
             "  caches     Inline caches\n"
             "  osi        Invalidation\n"
             "  safepoints Safepoints\n"
             "  pools      Literal Pools (ARM only for now)\n"
             "  cacheflush Instruction Cache flushes (ARM only for now)\n"
             "  logs       C1 and JSON visualization logging\n"
-            "  trace      Generate calls to js::ion::Trace() for effectful instructions\n"
+            "  trace      Generate calls to js::jit::Trace() for effectful instructions\n"
             "  all        Everything\n"
             "\n"
             "  bl-aborts  Baseline compiler abort messages\n"
             "  bl-scripts Baseline script-compilation\n"
             "  bl-op      Baseline compiler detailed op-specific messages\n"
             "  bl-ic      Baseline inline-cache messages\n"
             "  bl-ic-fb   Baseline IC fallback stub messages\n"
             "  bl-osr     Baseline IC OSR messages\n"
@@ -330,100 +330,100 @@ ion::CheckLogging()
 
     if (LoggingBits != 0)
         EnableIonDebugLogging();
 
     IonSpewFile = stderr;
 }
 
 void
-ion::IonSpewStartVA(IonSpewChannel channel, const char *fmt, va_list ap)
+jit::IonSpewStartVA(IonSpewChannel channel, const char *fmt, va_list ap)
 {
     if (!IonSpewEnabled(channel))
         return;
 
     IonSpewHeader(channel);
     vfprintf(stderr, fmt, ap);
 }
 
 void
-ion::IonSpewContVA(IonSpewChannel channel, const char *fmt, va_list ap)
+jit::IonSpewContVA(IonSpewChannel channel, const char *fmt, va_list ap)
 {
     if (!IonSpewEnabled(channel))
         return;
 
     vfprintf(stderr, fmt, ap);
 }
 
 void
-ion::IonSpewFin(IonSpewChannel channel)
+jit::IonSpewFin(IonSpewChannel channel)
 {
     if (!IonSpewEnabled(channel))
         return;
 
     fprintf(stderr, "\n");
 }
 
 void
-ion::IonSpewVA(IonSpewChannel channel, const char *fmt, va_list ap)
+jit::IonSpewVA(IonSpewChannel channel, const char *fmt, va_list ap)
 {
     IonSpewStartVA(channel, fmt, ap);
     IonSpewFin(channel);
 }
 
 void
-ion::IonSpew(IonSpewChannel channel, const char *fmt, ...)
+jit::IonSpew(IonSpewChannel channel, const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
     IonSpewVA(channel, fmt, ap);
     va_end(ap);
 }
 
 void
-ion::IonSpewStart(IonSpewChannel channel, const char *fmt, ...)
+jit::IonSpewStart(IonSpewChannel channel, const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
     IonSpewStartVA(channel, fmt, ap);
     va_end(ap);
 }
 void
-ion::IonSpewCont(IonSpewChannel channel, const char *fmt, ...)
+jit::IonSpewCont(IonSpewChannel channel, const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
     IonSpewContVA(channel, fmt, ap);
     va_end(ap);
 }
 
 void
-ion::IonSpewHeader(IonSpewChannel channel)
+jit::IonSpewHeader(IonSpewChannel channel)
 {
     if (!IonSpewEnabled(channel))
         return;
 
     fprintf(stderr, "[%s] ", ChannelNames[channel]);
 }
 
 bool
-ion::IonSpewEnabled(IonSpewChannel channel)
+jit::IonSpewEnabled(IonSpewChannel channel)
 {
     JS_ASSERT(LoggingChecked);
     return (LoggingBits & (1 << uint32_t(channel))) && !filteredOutCompilations;
 }
 
 void
-ion::EnableChannel(IonSpewChannel channel)
+jit::EnableChannel(IonSpewChannel channel)
 {
     JS_ASSERT(LoggingChecked);
     LoggingBits |= (1 << uint32_t(channel));
 }
 
 void
-ion::DisableChannel(IonSpewChannel channel)
+jit::DisableChannel(IonSpewChannel channel)
 {
     JS_ASSERT(LoggingChecked);
     LoggingBits &= ~(1 << uint32_t(channel));
 }
 
 #endif /* DEBUG */
 
--- a/js/src/jit/IonSpewer.h
+++ b/js/src/jit/IonSpewer.h
@@ -10,17 +10,17 @@
 #include "mozilla/DebugOnly.h"
 
 #include <stdarg.h>
 
 #include "jit/C1Spewer.h"
 #include "jit/JSONSpewer.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // New channels may be added below.
 #define IONSPEW_CHANNEL_LIST(_)             \
     /* Used to abort SSA construction */    \
     _(Abort)                                \
     /* Information about compiled scripts */\
     _(Scripts)                              \
     /* Information during MIR building */   \
@@ -46,17 +46,17 @@ namespace ion {
     /* Debug info about snapshots */        \
     _(Snapshots)                            \
     /* Generated inline cache stubs */      \
     _(InlineCaches)                         \
     /* Debug info about safepoints */       \
     _(Safepoints)                           \
     /* Debug info about Pools*/             \
     _(Pools)                                \
-    /* Calls to js::ion::Trace() */         \
+    /* Calls to js::jit::Trace() */         \
     _(Trace)                                \
     /* Debug info about the I$ */           \
     _(CacheFlush)                           \
                                             \
     /* BASELINE COMPILER SPEW */            \
                                             \
     /* Aborting Script Compilation. */      \
     _(BaselineAbort)                        \
--- a/js/src/jit/IonTypes.h
+++ b/js/src/jit/IonTypes.h
@@ -7,17 +7,17 @@
 #ifndef jit_IonTypes_h
 #define jit_IonTypes_h
 
 #include "jstypes.h"
 
 #include "js/Value.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 typedef uint32_t SnapshotOffset;
 typedef uint32_t BailoutId;
 
 static const SnapshotOffset INVALID_SNAPSHOT_OFFSET = uint32_t(-1);
 
 // Different kinds of bailouts. When extending this enum, make sure to check
 // the bits reserved for bailout kinds in Bailouts.h
@@ -201,12 +201,12 @@ IsNullOrUndefined(MIRType type)
     return type == MIRType_Null || type == MIRType_Undefined;
 }
 
 #ifdef DEBUG
 // Track the pipeline of opcodes which has produced a snapshot.
 #define TRACK_SNAPSHOTS 1
 #endif
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_IonTypes_h */
--- a/js/src/jit/JSONSpewer.cpp
+++ b/js/src/jit/JSONSpewer.cpp
@@ -10,17 +10,17 @@
 
 #include "jit/LinearScan.h"
 #include "jit/LIR.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/RangeAnalysis.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 JSONSpewer::~JSONSpewer()
 {
     if (fp_)
         fclose(fp_);
 }
 
 void
--- a/js/src/jit/JSONSpewer.h
+++ b/js/src/jit/JSONSpewer.h
@@ -11,17 +11,17 @@
 
 #include "jsscript.h"
 
 #include "js/RootingAPI.h"
 
 class JSScript;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MDefinition;
 class MInstruction;
 class MBasicBlock;
 class MIRGraph;
 class MResumePoint;
 class LinearScanAllocator;
 class LInstruction;
@@ -68,12 +68,12 @@ class JSONSpewer
     void spewLIns(LInstruction *ins);
     void spewLIR(MIRGraph *mir);
     void spewIntervals(LinearScanAllocator *regalloc);
     void endPass();
     void endFunction();
     void finish();
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_JSONSpewer_h */
--- a/js/src/jit/LICM.cpp
+++ b/js/src/jit/LICM.cpp
@@ -10,17 +10,17 @@
 
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 namespace {
 
 typedef Vector<MBasicBlock*, 1, IonAllocPolicy> BlockQueue;
 typedef Vector<MInstruction*, 1, IonAllocPolicy> InstructionQueue;
 
 class Loop
 {
--- a/js/src/jit/LICM.h
+++ b/js/src/jit/LICM.h
@@ -10,24 +10,24 @@
 #include "jit/IonAllocPolicy.h"
 #include "jit/IonAnalysis.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 // This file represents the Loop Invariant Code Motion optimization pass
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LICM
 {
     MIRGenerator *mir;
     MIRGraph &graph;
 
   public:
     LICM(MIRGenerator *mir, MIRGraph &graph);
     bool analyze();
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_LICM_h */
--- a/js/src/jit/LIR-Common.h
+++ b/js/src/jit/LIR-Common.h
@@ -7,17 +7,17 @@
 #ifndef jit_LIR_Common_h
 #define jit_LIR_Common_h
 
 #include "jit/shared/Assembler-shared.h"
 
 // This file declares LIR instructions that are common to every platform.
 
 namespace js {
-namespace ion {
+namespace jit {
 
 template <size_t Temps, size_t ExtraUses = 0>
 class LBinaryMath : public LInstructionHelper<1, 2 + ExtraUses, Temps>
 {
   public:
     const LAllocation *lhs() {
         return this->getOperand(0);
     }
@@ -4931,12 +4931,12 @@ class LAsmJSCheckOverRecursed : public L
   public:
     LIR_HEADER(AsmJSCheckOverRecursed)
 
     MAsmJSCheckOverRecursed *mir() const {
         return mir_->toAsmJSCheckOverRecursed();
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_LIR_Common_h */
--- a/js/src/jit/LIR.cpp
+++ b/js/src/jit/LIR.cpp
@@ -9,17 +9,17 @@
 #include "jsprf.h"
 
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/shared/CodeGenerator-shared.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 LIRGraph::LIRGraph(MIRGraph *mir)
   : numVirtualRegisters_(0),
     numInstructions_(1), // First id is 1.
     localSlotCount_(0),
     argumentSlotCount_(0),
     entrySnapshot_(NULL),
     osrBlock_(NULL),
--- a/js/src/jit/LIR.h
+++ b/js/src/jit/LIR.h
@@ -21,17 +21,17 @@
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/Registers.h"
 #include "jit/Safepoints.h"
 #include "jit/shared/Assembler-shared.h"
 #include "jit/VMFunctions.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LUse;
 class LGeneralReg;
 class LFloatReg;
 class LStackSlot;
 class LArgument;
 class LConstantIndex;
 class MBasicBlock;
@@ -1440,17 +1440,17 @@ AnyRegister
 LAllocation::toRegister() const
 {
     JS_ASSERT(isRegister());
     if (isFloatReg())
         return AnyRegister(toFloatReg()->reg());
     return AnyRegister(toGeneralReg()->reg());
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #define LIR_HEADER(opcode)                                                  \
     Opcode op() const {                                                     \
         return LInstruction::LOp_##opcode;                                  \
     }                                                                       \
     bool accept(LInstructionVisitor *visitor) {                             \
         visitor->setInstruction(this);                                      \
@@ -1482,17 +1482,17 @@ LAllocation::toRegister() const
 # include "jit/shared/LIR-x86-shared.h"
 #elif defined(JS_CPU_ARM)
 # include "jit/arm/LIR-arm.h"
 #endif
 
 #undef LIR_HEADER
 
 namespace js {
-namespace ion {
+namespace jit {
 
 #define LIROP(name)                                                         \
     L##name *LInstruction::to##name()                                       \
     {                                                                       \
         JS_ASSERT(is##name());                                              \
         return static_cast<L##name *>(this);                                \
     }
     LIR_OPCODE_LIST(LIROP)
@@ -1551,12 +1551,12 @@ static inline unsigned
 BaseOfNunboxSlot(LDefinition::Type type, unsigned slot)
 {
     if (type == LDefinition::PAYLOAD)
         return slot + (NUNBOX32_PAYLOAD_OFFSET / STACK_SLOT_SIZE);
     return slot + (NUNBOX32_TYPE_OFFSET / STACK_SLOT_SIZE);
 }
 #endif
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_LIR_h */
--- a/js/src/jit/LinearScan.cpp
+++ b/js/src/jit/LinearScan.cpp
@@ -10,17 +10,17 @@
 
 #include <limits.h>
 
 #include "jit/BitSet.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonSpewer.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 /*
  * Merge virtual register intervals into the UnhandledQueue, taking advantage
  * of their nearly-sorted ordering.
  */
 void
--- a/js/src/jit/LinearScan.h
+++ b/js/src/jit/LinearScan.h
@@ -7,17 +7,17 @@
 #ifndef jit_LinearScan_h
 #define jit_LinearScan_h
 
 #include "jit/BitSet.h"
 #include "jit/LiveRangeAllocator.h"
 #include "js/Vector.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LinearScanVirtualRegister : public VirtualRegister
 {
   private:
     LAllocation *canonicalSpill_;
     CodePosition spillPosition_ ;
 
     bool spillAtDefinition_ : 1;
@@ -125,12 +125,12 @@ class LinearScanAllocator : public LiveR
     LinearScanAllocator(MIRGenerator *mir, LIRGenerator *lir, LIRGraph &graph)
       : LiveRangeAllocator<LinearScanVirtualRegister>(mir, lir, graph, /* forLSRA = */ true)
     {
     }
 
     bool go();
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_LinearScan_h */
--- a/js/src/jit/LiveRangeAllocator.cpp
+++ b/js/src/jit/LiveRangeAllocator.cpp
@@ -7,17 +7,17 @@
 #include "jit/LiveRangeAllocator.h"
 
 #include "mozilla/DebugOnly.h"
 
 #include "jit/BacktrackingAllocator.h"
 #include "jit/LinearScan.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 int
 Requirement::priority() const
 {
     switch (kind_) {
       case Requirement::FIXED:
--- a/js/src/jit/LiveRangeAllocator.h
+++ b/js/src/jit/LiveRangeAllocator.h
@@ -12,17 +12,17 @@
 
 #include "jit/RegisterAllocator.h"
 #include "jit/StackSlotAllocator.h"
 
 // Common structures and functions used by register allocators that operate on
 // virtual register live ranges.
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class Requirement
 {
   public:
     enum Kind {
         NONE,
         REGISTER,
         FIXED,
@@ -636,12 +636,12 @@ class LiveRangeAllocator : public Regist
             LInstruction *ins = graph.getSafepoint(i);
             if (interval->start() <= inputOf(ins))
                 break;
         }
         return i;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_LiveRangeAllocator_h */
--- a/js/src/jit/Lowering.cpp
+++ b/js/src/jit/Lowering.cpp
@@ -18,17 +18,17 @@
 #include "jit/MIRGraph.h"
 #include "jit/RangeAnalysis.h"
 
 #include "jsinferinlines.h"
 
 #include "jit/shared/Lowering-shared-inl.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 bool
 LIRGenerator::visitParameter(MParameter *param)
 {
     ptrdiff_t offset;
     if (param->index() == MParameter::THIS_SLOT)
         offset = THIS_FRAME_SLOT;
     else
--- a/js/src/jit/Lowering.h
+++ b/js/src/jit/Lowering.h
@@ -19,17 +19,17 @@
 # include "jit/x64/Lowering-x64.h"
 #elif defined(JS_CPU_ARM)
 # include "jit/arm/Lowering-arm.h"
 #else
 # error "CPU!"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LIRGenerator : public LIRGeneratorSpecific
 {
     void updateResumeState(MInstruction *ins);
     void updateResumeState(MBasicBlock *block);
 
     // The active depth of the (perhaps nested) call argument vectors.
     uint32_t argslots_;
@@ -245,12 +245,12 @@ class LIRGenerator : public LIRGenerator
     bool visitAsmJSVoidReturn(MAsmJSVoidReturn *ins);
     bool visitAsmJSPassStackArg(MAsmJSPassStackArg *ins);
     bool visitAsmJSCall(MAsmJSCall *ins);
     bool visitAsmJSCheckOverRecursed(MAsmJSCheckOverRecursed *ins);
     bool visitSetDOMProperty(MSetDOMProperty *ins);
     bool visitGetDOMProperty(MGetDOMProperty *ins);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_Lowering_h */
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -13,17 +13,17 @@
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 #include "jsscriptinlines.h"
 
 #include "vm/StringObject-inl.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 IonBuilder::InliningStatus
 IonBuilder::inlineNativeCall(CallInfo &callInfo, JSNative native)
 {
     // Array natives.
     if (native == js_Array)
         return inlineArray(callInfo);
     if (native == js::array_pop)
@@ -1510,10 +1510,10 @@ IonBuilder::inlineBailout(CallInfo &call
     current->add(MBail::New());
 
     MConstant *undefined = MConstant::New(UndefinedValue());
     current->add(undefined);
     current->push(undefined);
     return InliningStatus_Inlined;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -20,17 +20,17 @@
 #include "jit/RangeAnalysis.h"
 
 #include "jsatominlines.h"
 #include "jsinferinlines.h"
 
 #include "vm/Shape-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DoublesAreIdentical;
 
 void
 MDefinition::PrintOpcodeName(FILE *fp, MDefinition::Opcode op)
 {
     static const char * const names[] =
     {
@@ -356,17 +356,17 @@ MDefinition::emptyResultTypeSet() const
 
 MConstant *
 MConstant::New(const Value &v)
 {
     return new MConstant(v);
 }
 
 types::StackTypeSet *
-ion::MakeSingletonTypeSet(JSObject *obj)
+jit::MakeSingletonTypeSet(JSObject *obj)
 {
     LifoAlloc *alloc = GetIonContext()->temp->lifoAlloc();
     types::StackTypeSet *types = alloc->new_<types::StackTypeSet>();
     if (!types)
         return NULL;
     types::Type objectType = types::Type::ObjectType(obj);
     types->addObject(objectType.objectKey(), alloc);
     return types;
@@ -679,17 +679,17 @@ MakeMIRTypeSet(MIRType type)
     JS_ASSERT(type != MIRType_Value);
     types::Type ntype = type == MIRType_Object
                         ? types::Type::AnyObjectType()
                         : types::Type::PrimitiveType(ValueTypeFromMIRType(type));
     return GetIonContext()->temp->lifoAlloc()->new_<types::StackTypeSet>(ntype);
 }
 
 void
-ion::MergeTypes(MIRType *ptype, types::StackTypeSet **ptypeSet,
+jit::MergeTypes(MIRType *ptype, types::StackTypeSet **ptypeSet,
                 MIRType newType, types::StackTypeSet *newTypeSet)
 {
     if (newTypeSet && newTypeSet->empty())
         return;
     if (newType != *ptype) {
         if (IsNumberType(newType) && IsNumberType(*ptype)) {
             *ptype = MIRType_Double;
         } else if (*ptype != MIRType_Value) {
@@ -2421,69 +2421,69 @@ MAsmJSCall::New(Callee callee, const Arg
         call->setOperand(i, args[i].def);
     if (callee.which() == Callee::Dynamic)
         call->setOperand(call->numArgs_, callee.dynamic());
 
     return call;
 }
 
 bool
-ion::ElementAccessIsDenseNative(MDefinition *obj, MDefinition *id)
+jit::ElementAccessIsDenseNative(MDefinition *obj, MDefinition *id)
 {
     if (obj->mightBeType(MIRType_String))
         return false;
 
     if (id->type() != MIRType_Int32 && id->type() != MIRType_Double)
         return false;
 
     types::StackTypeSet *types = obj->resultTypeSet();
     if (!types)
         return false;
 
     Class *clasp = types->getKnownClass();
     return clasp && clasp->isNative();
 }
 
 bool
-ion::ElementAccessIsTypedArray(MDefinition *obj, MDefinition *id, int *arrayType)
+jit::ElementAccessIsTypedArray(MDefinition *obj, MDefinition *id, int *arrayType)
 {
     if (obj->mightBeType(MIRType_String))
         return false;
 
     if (id->type() != MIRType_Int32 && id->type() != MIRType_Double)
         return false;
 
     types::StackTypeSet *types = obj->resultTypeSet();
     if (!types)
         return false;
 
     *arrayType = types->getTypedArrayType();
     return *arrayType != TypedArrayObject::TYPE_MAX;
 }
 
 bool
-ion::ElementAccessIsPacked(JSContext *cx, MDefinition *obj)
+jit::ElementAccessIsPacked(JSContext *cx, MDefinition *obj)
 {
     types::StackTypeSet *types = obj->resultTypeSet();
     return types && !types->hasObjectFlags(cx, types::OBJECT_FLAG_NON_PACKED);
 }
 
 bool
-ion::ElementAccessHasExtraIndexedProperty(JSContext *cx, MDefinition *obj)
+jit::ElementAccessHasExtraIndexedProperty(JSContext *cx, MDefinition *obj)
 {
     types::StackTypeSet *types = obj->resultTypeSet();
 
     if (!types || types->hasObjectFlags(cx, types::OBJECT_FLAG_LENGTH_OVERFLOW))
         return true;
 
     return types::TypeCanHaveExtraIndexedProperties(cx, types);
 }
 
 MIRType
-ion::DenseNativeElementType(JSContext *cx, MDefinition *obj)
+jit::DenseNativeElementType(JSContext *cx, MDefinition *obj)
 {
     types::StackTypeSet *types = obj->resultTypeSet();
     MIRType elementType = MIRType_None;
     unsigned count = types->getObjectCount();
 
     for (unsigned i = 0; i < count; i++) {
         if (types::TypeObject *object = types->getTypeOrSingleObject(cx, i)) {
             if (object->unknownProperties())
@@ -2503,17 +2503,17 @@ ion::DenseNativeElementType(JSContext *c
                 return MIRType_None;
         }
     }
 
     return elementType;
 }
 
 bool
-ion::PropertyReadNeedsTypeBarrier(JSContext *cx, types::TypeObject *object, PropertyName *name,
+jit::PropertyReadNeedsTypeBarrier(JSContext *cx, types::TypeObject *object, PropertyName *name,
                                   types::StackTypeSet *observed, bool updateObserved)
 {
     // If the object being read from has types for the property which haven't
     // been observed at this access site, the read could produce a new type and
     // a barrier is needed. Note that this only covers reads from properties
     // which are accounted for by type information, i.e. native data properties
     // and elements.
 
@@ -2570,17 +2570,17 @@ ion::PropertyReadNeedsTypeBarrier(JSCont
         }
     }
 
     property->addFreeze(cx);
     return false;
 }
 
 bool
-ion::PropertyReadNeedsTypeBarrier(JSContext *cx, MDefinition *obj, PropertyName *name,
+jit::PropertyReadNeedsTypeBarrier(JSContext *cx, MDefinition *obj, PropertyName *name,
                                   types::StackTypeSet *observed)
 {
     if (observed->unknown())
         return false;
 
     types::TypeSet *types = obj->resultTypeSet();
     if (!types || types->unknownObject())
         return true;
@@ -2591,17 +2591,17 @@ ion::PropertyReadNeedsTypeBarrier(JSCont
         if (object && PropertyReadNeedsTypeBarrier(cx, object, name, observed, updateObserved))
             return true;
     }
 
     return false;
 }
 
 bool
-ion::PropertyReadIsIdempotent(JSContext *cx, MDefinition *obj, PropertyName *name)
+jit::PropertyReadIsIdempotent(JSContext *cx, MDefinition *obj, PropertyName *name)
 {
     // Determine if reading a property from obj is likely to be idempotent.
 
     jsid id = types::IdToTypeId(NameToId(name));
 
     types::TypeSet *types = obj->resultTypeSet();
     if (!types || types->unknownObject())
         return false;
@@ -2617,17 +2617,17 @@ ion::PropertyReadIsIdempotent(JSContext 
                 return false;
         }
     }
 
     return true;
 }
 
 void
-ion::AddObjectsForPropertyRead(JSContext *cx, MDefinition *obj, PropertyName *name,
+jit::AddObjectsForPropertyRead(JSContext *cx, MDefinition *obj, PropertyName *name,
                                types::StackTypeSet *observed)
 {
     // Add objects to observed which *could* be observed by reading name from obj,
     // to hopefully avoid unnecessary type barriers and code invalidations.
 
     JS_ASSERT(observed->noConstraints());
 
     types::StackTypeSet *types = obj->resultTypeSet();
@@ -2749,17 +2749,17 @@ AddTypeGuard(MBasicBlock *current, MDefi
 
     // For now, never move type object guards.
     guard->setNotMovable();
 
     return guard;
 }
 
 bool
-ion::PropertyWriteNeedsTypeBarrier(JSContext *cx, MBasicBlock *current, MDefinition **pobj,
+jit::PropertyWriteNeedsTypeBarrier(JSContext *cx, MBasicBlock *current, MDefinition **pobj,
                                    PropertyName *name, MDefinition **pvalue, bool canModify)
 {
     // If any value being written is not reflected in the type information for
     // objects which obj could represent, a type barrier is needed when writing
     // the value. As for propertyReadNeedsTypeBarrier, this only applies for
     // properties that are accounted for by type information, i.e. normal data
     // properties and elements.
 
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -27,17 +27,17 @@
 #include "jit/MOpcodes.h"
 #include "jit/TypePolicy.h"
 #include "vm/ScopeObject.h"
 
 namespace js {
 
 class StringObject;
 
-namespace ion {
+namespace jit {
 
 class BaselineInspector;
 class ValueNumberData;
 class Range;
 
 static const inline
 MIRType MIRTypeFromValue(const js::Value &vp)
 {
@@ -8598,12 +8598,12 @@ bool PropertyReadNeedsTypeBarrier(JSCont
                                   types::StackTypeSet *observed);
 bool PropertyReadIsIdempotent(JSContext *cx, MDefinition *obj, PropertyName *name);
 void AddObjectsForPropertyRead(JSContext *cx, MDefinition *obj, PropertyName *name,
                                types::StackTypeSet *observed);
 bool PropertyWriteNeedsTypeBarrier(JSContext *cx, MBasicBlock *current, MDefinition **pobj,
                                    PropertyName *name, MDefinition **pvalue,
                                    bool canModify = true);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_MIR_h */
--- a/js/src/jit/MIRGenerator.h
+++ b/js/src/jit/MIRGenerator.h
@@ -19,17 +19,17 @@
 #include "jit/IonAllocPolicy.h"
 #include "jit/IonCompartment.h"
 #if defined(JS_ION_PERF)
 # include "jit/PerfSpewer.h"
 #endif
 #include "jit/RegisterSets.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MBasicBlock;
 class MIRGraph;
 class MStart;
 
 struct AsmJSGlobalAccess
 {
     unsigned offset;
@@ -151,12 +151,12 @@ class MIRGenerator
 #if defined(JS_ION_PERF)
     AsmJSPerfSpewer asmJSPerfSpewer_;
 
   public:
     AsmJSPerfSpewer &perfSpewer() { return asmJSPerfSpewer_; }
 #endif
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_MIRGenerator_h */
--- a/js/src/jit/MIRGraph.cpp
+++ b/js/src/jit/MIRGraph.cpp
@@ -11,17 +11,17 @@
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 
 #include "jsinferinlines.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 MIRGenerator::MIRGenerator(JSCompartment *compartment,
                            TempAllocator *temp, MIRGraph *graph, CompileInfo *info)
   : compartment(compartment),
     info_(info),
     temp_(temp),
     graph_(graph),
     error_(false),
--- a/js/src/jit/MIRGraph.h
+++ b/js/src/jit/MIRGraph.h
@@ -11,17 +11,17 @@
 // containing MIR.
 
 #include "jit/FixedList.h"
 #include "jit/IonAllocPolicy.h"
 #include "jit/MIR.h"
 #include "jit/MIRGenerator.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MBasicBlock;
 class MIRGraph;
 class MStart;
 
 class MDefinitionIterator;
 
 typedef InlineListIterator<MInstruction> MInstructionIterator;
@@ -740,12 +740,12 @@ class MDefinitionIterator
     }
 
     MDefinition *operator ->() {
         return getIns();
     }
 
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_MIRGraph_h */
--- a/js/src/jit/MOpcodes.h
+++ b/js/src/jit/MOpcodes.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_MOpcodes_h
 #define jit_MOpcodes_h
 
 namespace js {
-namespace ion {
+namespace jit {
 
 #define MIR_OPCODE_LIST(_)                                                  \
     _(Constant)                                                             \
     _(Parameter)                                                            \
     _(Callee)                                                               \
     _(ForceUse)                                                             \
     _(TableSwitch)                                                          \
     _(Goto)                                                                 \
@@ -217,12 +217,12 @@ class MInstructionVisitor // interface i
 class MInstructionVisitorWithDefaults : public MInstructionVisitor
 {
   public:
 #define VISIT_INS(op) virtual bool visit##op(M##op *) { MOZ_ASSUME_UNREACHABLE("NYI: " #op); }
     MIR_OPCODE_LIST(VISIT_INS)
 #undef VISIT_INS
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_MOpcodes_h */
--- a/js/src/jit/MoveResolver.cpp
+++ b/js/src/jit/MoveResolver.cpp
@@ -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/. */
 
 #include "jit/MoveResolver.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 MoveResolver::MoveResolver()
   : hasCycles_(false)
 {
 }
 
 void
 MoveResolver::resetState()
--- a/js/src/jit/MoveResolver.h
+++ b/js/src/jit/MoveResolver.h
@@ -7,17 +7,17 @@
 #ifndef jit_MoveResolver_h
 #define jit_MoveResolver_h
 
 #include "jit/InlineList.h"
 #include "jit/IonAllocPolicy.h"
 #include "jit/Registers.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MoveResolver
 {
   public:
     // This is similar to Operand, but carries more information. We're also not
     // guaranteed that Operand looks like this on all ISAs.
     class MoveOperand
     {
@@ -208,12 +208,12 @@ class MoveResolver
     bool hasCycles() const {
         return hasCycles_;
     }
     void clearTempObjectPool() {
         movePool_.clear();
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_MoveResolver_h */
--- a/js/src/jit/ParallelFunctions.cpp
+++ b/js/src/jit/ParallelFunctions.cpp
@@ -10,45 +10,45 @@
 #include "vm/ArrayObject.h"
 #include "vm/Interpreter.h"
 
 #include "jsfuninlines.h"
 #include "jsgcinlines.h"
 #include "jsobjinlines.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 using parallel::Spew;
 using parallel::SpewOps;
 using parallel::SpewBailouts;
 using parallel::SpewBailoutIR;
 
 // Load the current thread context.
 ForkJoinSlice *
-ion::ForkJoinSlicePar()
+jit::ForkJoinSlicePar()
 {
     return ForkJoinSlice::Current();
 }
 
 // NewGCThingPar() is called in place of NewGCThing() when executing
 // parallel code.  It uses the ArenaLists for the current thread and
 // allocates from there.
 JSObject *
-ion::NewGCThingPar(gc::AllocKind allocKind)
+jit::NewGCThingPar(gc::AllocKind allocKind)
 {
     ForkJoinSlice *slice = ForkJoinSlice::Current();
     uint32_t thingSize = (uint32_t)gc::Arena::thingSize(allocKind);
     return gc::NewGCThing<JSObject, NoGC>(slice, allocKind, thingSize, gc::DefaultHeap);
 }
 
 // Check that the object was created by the current thread
 // (and hence is writable).
 bool
-ion::IsThreadLocalObject(ForkJoinSlice *slice, JSObject *object)
+jit::IsThreadLocalObject(ForkJoinSlice *slice, JSObject *object)
 {
     JS_ASSERT(ForkJoinSlice::Current() == slice);
     return !IsInsideNursery(slice->runtime(), object) &&
            slice->allocator()->arenas.containsArena(slice->runtime(), object->arenaHeader());
 }
 
 #ifdef DEBUG
 static void
@@ -58,17 +58,17 @@ printTrace(const char *prefix, struct Io
             prefix,
             cached->bblock, cached->lir, cached->execModeInt, cached->lirOpName);
 }
 
 struct IonLIRTraceData seqTraceData;
 #endif
 
 void
-ion::TraceLIR(uint32_t bblock, uint32_t lir, uint32_t execModeInt,
+jit::TraceLIR(uint32_t bblock, uint32_t lir, uint32_t execModeInt,
               const char *lirOpName, const char *mirOpName,
               JSScript *script, jsbytecode *pc)
 {
 #ifdef DEBUG
     static enum { NotSet, All, Bailouts } traceMode;
 
     // If you set IONFLAGS=trace, this function will be invoked before every LIR.
     //
@@ -113,17 +113,17 @@ ion::TraceLIR(uint32_t bblock, uint32_t 
     cached->pc = pc;
 
     if (traceMode == All)
         printTrace("Exec", cached);
 #endif
 }
 
 bool
-ion::CheckOverRecursedPar(ForkJoinSlice *slice)
+jit::CheckOverRecursedPar(ForkJoinSlice *slice)
 {
     JS_ASSERT(ForkJoinSlice::Current() == slice);
     int stackDummy_;
 
     // When an interrupt is triggered, the main thread stack limit is
     // overwritten with a sentinel value that brings us here.
     // Therefore, we must check whether this is really a stack overrun
     // and, if not, check whether an interrupt is needed.
@@ -143,88 +143,88 @@ ion::CheckOverRecursedPar(ForkJoinSlice 
                                        NULL, NULL, NULL);
         return false;
     }
 
     return CheckInterruptPar(slice);
 }
 
 bool
-ion::CheckInterruptPar(ForkJoinSlice *slice)
+jit::CheckInterruptPar(ForkJoinSlice *slice)
 {
     JS_ASSERT(ForkJoinSlice::Current() == slice);
     bool result = slice->check();
     if (!result) {
         // Do not set the cause here.  Either it was set by this
         // thread already by some code that then triggered an abort,
         // or else we are just picking up an abort from some other
         // thread.  Either way we have nothing useful to contribute so
         // we might as well leave our bailout case unset.
         return false;
     }
     return true;
 }
 
 JSObject *
-ion::PushPar(PushParArgs *args)
+jit::PushPar(PushParArgs *args)
 {
     // It is awkward to have the MIR pass the current slice in, so
     // just fetch it from TLS.  Extending the array is kind of the
     // slow path anyhow as it reallocates the elements vector.
     ForkJoinSlice *slice = js::ForkJoinSlice::Current();
     JSObject::EnsureDenseResult res =
         args->object->parExtendDenseElements(slice, &args->value, 1);
     if (res != JSObject::ED_OK)
         return NULL;
     return args->object;
 }
 
 JSObject *
-ion::ExtendArrayPar(ForkJoinSlice *slice, JSObject *array, uint32_t length)
+jit::ExtendArrayPar(ForkJoinSlice *slice, JSObject *array, uint32_t length)
 {
     JSObject::EnsureDenseResult res =
         array->parExtendDenseElements(slice, NULL, length);
     if (res != JSObject::ED_OK)
         return NULL;
     return array;
 }
 
 ParallelResult
-ion::ConcatStringsPar(ForkJoinSlice *slice, HandleString left, HandleString right,
+jit::ConcatStringsPar(ForkJoinSlice *slice, HandleString left, HandleString right,
                       MutableHandleString out)
 {
     JSString *str = ConcatStrings<NoGC>(slice, left, right);
     if (!str)
         return TP_RETRY_SEQUENTIALLY;
     out.set(str);
     return TP_SUCCESS;
 }
 
 ParallelResult
-ion::IntToStringPar(ForkJoinSlice *slice, int i, MutableHandleString out)
+jit::IntToStringPar(ForkJoinSlice *slice, int i, MutableHandleString out)
 {
     JSFlatString *str = Int32ToString<NoGC>(slice, i);
     if (!str)
         return TP_RETRY_SEQUENTIALLY;
     out.set(str);
     return TP_SUCCESS;
 }
 
 ParallelResult
-ion::DoubleToStringPar(ForkJoinSlice *slice, double d, MutableHandleString out)
+jit::DoubleToStringPar(ForkJoinSlice *slice, double d, MutableHandleString out)
 {
     JSString *str = js_NumberToString<NoGC>(slice, d);
     if (!str)
         return TP_RETRY_SEQUENTIALLY;
     out.set(str);
     return TP_SUCCESS;
 }
 
 ParallelResult
-ion::StringToNumberPar(ForkJoinSlice *slice, JSString *str, double *out)
+jit::StringToNumberPar(ForkJoinSlice *slice, JSString *str, double *out)
 {
     return StringToNumber(slice, str, out) ? TP_SUCCESS : TP_FATAL;
 }
 
 #define PAR_RELATIONAL_OP(OP, EXPECTED)                                         \
 do {                                                                            \
     /* Optimize for two int-tagged operands (typical loop control). */          \
     if (lhs.isInt32() && rhs.isInt32()) {                                       \
@@ -283,23 +283,23 @@ CompareMaybeStringsPar(ForkJoinSlice *sl
 template<bool Equal>
 ParallelResult
 LooselyEqualImplPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     PAR_RELATIONAL_OP(==, Equal);
 }
 
 ParallelResult
-js::ion::LooselyEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::LooselyEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     return LooselyEqualImplPar<true>(slice, lhs, rhs, res);
 }
 
 ParallelResult
-js::ion::LooselyUnequalPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::LooselyUnequalPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     return LooselyEqualImplPar<false>(slice, lhs, rhs, res);
 }
 
 template<bool Equal>
 ParallelResult
 StrictlyEqualImplPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
@@ -333,47 +333,47 @@ StrictlyEqualImplPar(ForkJoinSlice *slic
             return LooselyEqualImplPar<Equal>(slice, lhs, rhs, res);
     }
 
     *res = false;
     return TP_SUCCESS;
 }
 
 ParallelResult
-js::ion::StrictlyEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::StrictlyEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     return StrictlyEqualImplPar<true>(slice, lhs, rhs, res);
 }
 
 ParallelResult
-js::ion::StrictlyUnequalPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::StrictlyUnequalPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     return StrictlyEqualImplPar<false>(slice, lhs, rhs, res);
 }
 
 ParallelResult
-js::ion::LessThanPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::LessThanPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     PAR_RELATIONAL_OP(<, true);
 }
 
 ParallelResult
-js::ion::LessThanOrEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::LessThanOrEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     PAR_RELATIONAL_OP(<=, true);
 }
 
 ParallelResult
-js::ion::GreaterThanPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::GreaterThanPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     PAR_RELATIONAL_OP(>, true);
 }
 
 ParallelResult
-js::ion::GreaterThanOrEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
+js::jit::GreaterThanOrEqualPar(ForkJoinSlice *slice, MutableHandleValue lhs, MutableHandleValue rhs, bool *res)
 {
     PAR_RELATIONAL_OP(>=, true);
 }
 
 template<bool Equal>
 ParallelResult
 StringsEqualImplPar(ForkJoinSlice *slice, HandleString lhs, HandleString rhs, bool *res)
 {
@@ -381,29 +381,29 @@ StringsEqualImplPar(ForkJoinSlice *slice
     ParallelResult ret = CompareStringsPar(slice, lhs, rhs, &vsZero);
     if (ret != TP_SUCCESS)
         return ret;
     *res = (vsZero == 0) == Equal;
     return TP_SUCCESS;
 }
 
 ParallelResult
-js::ion::StringsEqualPar(ForkJoinSlice *slice, HandleString v1, HandleString v2, bool *res)
+js::jit::StringsEqualPar(ForkJoinSlice *slice, HandleString v1, HandleString v2, bool *res)
 {
     return StringsEqualImplPar<true>(slice, v1, v2, res);
 }
 
 ParallelResult
-js::ion::StringsUnequalPar(ForkJoinSlice *slice, HandleString v1, HandleString v2, bool *res)
+js::jit::StringsUnequalPar(ForkJoinSlice *slice, HandleString v1, HandleString v2, bool *res)
 {
     return StringsEqualImplPar<false>(slice, v1, v2, res);
 }
 
 ParallelResult
-ion::BitNotPar(ForkJoinSlice *slice, HandleValue in, int32_t *out)
+jit::BitNotPar(ForkJoinSlice *slice, HandleValue in, int32_t *out)
 {
     if (in.isObject())
         return TP_RETRY_SEQUENTIALLY;
     int i;
     if (!NonObjectToInt32(slice, in, &i))
         return TP_FATAL;
     *out = ~i;
     return TP_SUCCESS;
@@ -419,64 +419,64 @@ ion::BitNotPar(ForkJoinSlice *slice, Han
     {                                                                   \
         return TP_FATAL;                                                \
     }                                                                   \
     *out = (OP);                                                        \
     return TP_SUCCESS;                                                  \
     JS_END_MACRO
 
 ParallelResult
-ion::BitXorPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
+jit::BitXorPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
 {
     BIT_OP(left ^ right);
 }
 
 ParallelResult
-ion::BitOrPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
+jit::BitOrPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
 {
     BIT_OP(left | right);
 }
 
 ParallelResult
-ion::BitAndPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
+jit::BitAndPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
 {
     BIT_OP(left & right);
 }
 
 ParallelResult
-ion::BitLshPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
+jit::BitLshPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
 {
     BIT_OP(left << (right & 31));
 }
 
 ParallelResult
-ion::BitRshPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
+jit::BitRshPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs, int32_t *out)
 {
     BIT_OP(left >> (right & 31));
 }
 
 #undef BIT_OP
 
 ParallelResult
-ion::UrshValuesPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs,
+jit::UrshValuesPar(ForkJoinSlice *slice, HandleValue lhs, HandleValue rhs,
                    MutableHandleValue out)
 {
     uint32_t left;
     int32_t right;
     if (lhs.isObject() || rhs.isObject())
         return TP_RETRY_SEQUENTIALLY;
     if (!NonObjectToUint32(slice, lhs, &left) || !NonObjectToInt32(slice, rhs, &right))
         return TP_FATAL;
     left >>= right & 31;
     out.setNumber(uint32_t(left));
     return TP_SUCCESS;
 }
 
 void
-ion::AbortPar(ParallelBailoutCause cause, JSScript *outermostScript, JSScript *currentScript,
+jit::AbortPar(ParallelBailoutCause cause, JSScript *outermostScript, JSScript *currentScript,
               jsbytecode *bytecode)
 {
     // Spew before asserts to help with diagnosing failures.
     Spew(SpewBailouts,
          "Parallel abort with cause %d in %p:%s:%d "
          "(%p:%s:%d at line %d)",
          cause,
          outermostScript, outermostScript->filename(), outermostScript->lineno,
@@ -491,17 +491,17 @@ ion::AbortPar(ParallelBailoutCause cause
     ForkJoinSlice *slice = ForkJoinSlice::Current();
 
     JS_ASSERT(slice->bailoutRecord->depth == 0);
     slice->bailoutRecord->setCause(cause, outermostScript,
                                    currentScript, bytecode);
 }
 
 void
-ion::PropagateAbortPar(JSScript *outermostScript, JSScript *currentScript)
+jit::PropagateAbortPar(JSScript *outermostScript, JSScript *currentScript)
 {
     Spew(SpewBailouts,
          "Propagate parallel abort via %p:%s:%d (%p:%s:%d)",
          outermostScript, outermostScript->filename(), outermostScript->lineno,
          currentScript, currentScript->filename(), currentScript->lineno);
 
     JS_ASSERT(InParallelSection());
     JS_ASSERT(outermostScript->hasParallelIonScript());
@@ -509,17 +509,17 @@ ion::PropagateAbortPar(JSScript *outermo
     outermostScript->parallelIonScript()->setHasUncompiledCallTarget();
 
     ForkJoinSlice *slice = ForkJoinSlice::Current();
     if (currentScript)
         slice->bailoutRecord->addTrace(currentScript, NULL);
 }
 
 void
-ion::CallToUncompiledScriptPar(JSFunction *func)
+jit::CallToUncompiledScriptPar(JSFunction *func)
 {
     JS_ASSERT(InParallelSection());
 
 #ifdef DEBUG
     static const int max_bound_function_unrolling = 5;
 
     if (func->hasScript()) {
         JSScript *script = func->nonLazyScript();
@@ -547,17 +547,17 @@ ion::CallToUncompiledScriptPar(JSFunctio
     } else {
         JS_ASSERT(func->isNative());
         Spew(SpewBailouts, "Call to native function");
     }
 #endif
 }
 
 ParallelResult
-ion::InitRestParameterPar(ForkJoinSlice *slice, uint32_t length, Value *rest,
+jit::InitRestParameterPar(ForkJoinSlice *slice, uint32_t length, Value *rest,
                           HandleObject templateObj, HandleObject res,
                           MutableHandleObject out)
 {
     // In parallel execution, we should always have succeeded in allocation
     // before this point. We can do the allocation here like in the sequential
     // path, but duplicating the initGCThing logic is too tedious.
     JS_ASSERT(res);
     JS_ASSERT(res->is<ArrayObject>());
--- a/js/src/jit/ParallelFunctions.h
+++ b/js/src/jit/ParallelFunctions.h
@@ -7,17 +7,17 @@
 #ifndef jit_ParallelFunctions_h
 #define jit_ParallelFunctions_h
 
 #include "gc/Heap.h"
 #include "vm/ForkJoin.h"
 #include "vm/ThreadPool.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 ForkJoinSlice *ForkJoinSlicePar();
 JSObject *NewGCThingPar(gc::AllocKind allocKind);
 bool IsThreadLocalObject(ForkJoinSlice *context, JSObject *object);
 bool CheckOverRecursedPar(ForkJoinSlice *slice);
 bool CheckInterruptPar(ForkJoinSlice *context);
 
 // We pass the arguments to PushPar in a structure because, in code
@@ -81,12 +81,12 @@ void AbortPar(ParallelBailoutCause cause
 void PropagateAbortPar(JSScript *outermostScript, JSScript *currentScript);
 
 void TraceLIR(uint32_t bblock, uint32_t lir, uint32_t execModeInt,
               const char *lirOpName, const char *mirOpName,
               JSScript *script, jsbytecode *pc);
 
 void CallToUncompiledScriptPar(JSFunction *func);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_ParallelFunctions_h */
--- a/js/src/jit/ParallelSafetyAnalysis.cpp
+++ b/js/src/jit/ParallelSafetyAnalysis.cpp
@@ -14,17 +14,17 @@
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/UnreachableCodeElimination.h"
 #include "vm/Stack.h"
 
 #include "jsinferinlines.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 using parallel::Spew;
 using parallel::SpewMIR;
 using parallel::SpewCompile;
 
 #define SAFE_OP(op)                             \
     virtual bool visit##op(M##op *prop) { return true; }
 
@@ -768,17 +768,17 @@ ParallelSafetyVisitor::visitThrow(MThrow
 static bool
 GetPossibleCallees(JSContext *cx, HandleScript script, jsbytecode *pc,
                    types::StackTypeSet *calleeTypes, CallTargetVector &targets);
 
 static bool
 AddCallTarget(HandleScript script, CallTargetVector &targets);
 
 bool
-ion::AddPossibleCallees(MIRGraph &graph, CallTargetVector &targets)
+jit::AddPossibleCallees(MIRGraph &graph, CallTargetVector &targets)
 {
     JSContext *cx = GetIonContext()->cx;
 
     for (ReversePostorderIterator block(graph.rpoBegin()); block != graph.rpoEnd(); block++) {
         for (MInstructionIterator ins(block->begin()); ins != block->end(); ins++)
         {
             if (!ins->isCall())
                 continue;
--- a/js/src/jit/ParallelSafetyAnalysis.h
+++ b/js/src/jit/ParallelSafetyAnalysis.h
@@ -9,17 +9,17 @@
 
 #include "jit/CompileInfo.h"
 #include "jit/MIR.h"
 
 namespace js {
 
 class StackFrame;
 
-namespace ion {
+namespace jit {
 
 class MIRGraph;
 class AutoDestroyAllocator;
 
 // Determines whether a function is compatible for parallel execution.
 // Removes basic blocks containing unsafe MIR operations from the
 // graph and replaces them with MAbortPar blocks.
 class ParallelSafetyAnalysis
@@ -44,12 +44,12 @@ class ParallelSafetyAnalysis
 // 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;
 bool AddPossibleCallees(MIRGraph &graph, CallTargetVector &targets);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_ParallelSafetyAnalysis_h */
--- a/js/src/jit/PcScriptCache.h
+++ b/js/src/jit/PcScriptCache.h
@@ -2,23 +2,23 @@
  * 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_PcScriptCache_h
 #define jit_PcScriptCache_h
 
-// Defines a fixed-size hash table solely for the purpose of caching ion::GetPcScript().
+// Defines a fixed-size hash table solely for the purpose of caching jit::GetPcScript().
 // One cache is attached to each JSRuntime; it functions as if cleared on GC.
 
 struct JSRuntime;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 struct PcScriptCacheEntry
 {
     uint8_t *returnAddress; // Key into the hash table.
     jsbytecode *pc;         // Cached PC.
     JSScript *script;       // Cached script.
 };
 
@@ -67,12 +67,12 @@ struct PcScriptCache
     }
 
     static uint32_t Hash(uint8_t *addr) {
         uint32_t key = (uint32_t)((uintptr_t)addr);
         return ((key >> 3) * 2654435761u) % Length;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_PcScriptCache_h */
--- a/js/src/jit/PerfSpewer.cpp
+++ b/js/src/jit/PerfSpewer.cpp
@@ -15,29 +15,29 @@
 #include "jit/IonSpewer.h"
 #include "jit/LinearScan.h"
 #include "jit/LIR.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/RangeAnalysis.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 #define PERF_MODE_NONE  1
 #define PERF_MODE_FUNC  2
 #define PERF_MODE_BLOCK 3
 
 #ifdef JS_ION_PERF
 static uint32_t PerfMode = 0;
 
 static bool PerfChecked = false;
 
 void
-js::ion::CheckPerf() {
+js::jit::CheckPerf() {
     if (!PerfChecked) {
         const char *env = getenv("IONPERF");
         if (env == NULL) {
             PerfMode = PERF_MODE_NONE;
             fprintf(stderr, "Warning: JIT perf reporting requires IONPERF set to \"block\" or \"func\". ");
             fprintf(stderr, "Perf mapping will be deactivated.\n");
         } else if (!strcmp(env, "none")) {
             PerfMode = PERF_MODE_NONE;
@@ -53,23 +53,23 @@ js::ion::CheckPerf() {
             fprintf(stderr, "to be leaked.\n");
             exit(0);
         }
         PerfChecked = true;
     }
 }
 
 bool
-js::ion::PerfBlockEnabled() {
+js::jit::PerfBlockEnabled() {
     JS_ASSERT(PerfMode);
     return PerfMode == PERF_MODE_BLOCK;
 }
 
 bool
-js::ion::PerfFuncEnabled() {
+js::jit::PerfFuncEnabled() {
     JS_ASSERT(PerfMode);
     return PerfMode == PERF_MODE_FUNC;
 }
 
 #endif
 
 uint32_t PerfSpewer::nextFunctionIndex = 0;
 
--- a/js/src/jit/PerfSpewer.h
+++ b/js/src/jit/PerfSpewer.h
@@ -12,17 +12,17 @@
 #include "jsscript.h"
 
 #include "jit/IonMacroAssembler.h"
 #include "js/RootingAPI.h"
 
 class JSScript;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MBasicBlock;
 class MacroAssembler;
 
 #ifdef JS_ION_PERF
 void CheckPerf();
 bool PerfBlockEnabled();
 bool PerfFuncEnabled();
@@ -86,12 +86,12 @@ class AsmJSPerfSpewer : public PerfSpewe
 
     void writeBlocksMap(unsigned long baseAddress, unsigned long funcStartOffset,
                         unsigned long funcSize, const char *filename, const char *funcName,
                         const BasicBlocksVector &basicBlocks);
     void writeFunctionMap(unsigned long base, unsigned long size, const char *filename,
                           unsigned lineno, unsigned colIndex, const char *funcName);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_PerfSpewer_h */
--- a/js/src/jit/RangeAnalysis.cpp
+++ b/js/src/jit/RangeAnalysis.cpp
@@ -16,17 +16,17 @@
 #include "jit/Ion.h"
 #include "jit/IonAnalysis.h"
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "vm/NumericConversions.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::Abs;
 using mozilla::CountLeadingZeroes32;
 using mozilla::ExponentComponent;
 using mozilla::IsInfinite;
 using mozilla::IsNaN;
 using mozilla::IsNegative;
 using mozilla::Swap;
--- a/js/src/jit/RangeAnalysis.h
+++ b/js/src/jit/RangeAnalysis.h
@@ -10,17 +10,17 @@
 #include "mozilla/FloatingPoint.h"
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/CompileInfo.h"
 #include "jit/IonAnalysis.h"
 #include "jit/MIR.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MBasicBlock;
 class MIRGraph;
 
 // An upper bound computed on the number of backedges a loop will take.
 // This count only includes backedges taken while running Ion code: for OSR
 // loops, this will exclude iterations that executed in the interpreter or in
 // baseline compiled code.
@@ -392,12 +392,12 @@ class Range : public TempObject {
     inline void setSymbolicLower(SymbolicBound *bound) {
         symbolicLower_ = bound;
     }
     inline void setSymbolicUpper(SymbolicBound *bound) {
         symbolicUpper_ = bound;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_RangeAnalysis_h */
--- a/js/src/jit/RegisterAllocator.cpp
+++ b/js/src/jit/RegisterAllocator.cpp
@@ -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/. */
 
 #include "jit/RegisterAllocator.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 bool
 AllocationIntegrityState::record()
 {
     // Ignore repeated record() calls.
     if (!instructions.empty())
         return true;
 
--- a/js/src/jit/RegisterAllocator.h
+++ b/js/src/jit/RegisterAllocator.h
@@ -14,17 +14,17 @@
 #include "jit/LIR.h"
 #include "jit/Lowering.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 // Generic structures and functions for use by register allocators.
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // Structure for running a liveness analysis on a finished register allocation.
 // This analysis can be used for two purposes:
 //
 // - Check the integrity of the allocation, i.e. that the reads and writes of
 //   physical values preserve the semantics of the original virtual registers.
 //
 // - Populate safepoints with live registers, GC thing and value data, to
@@ -357,12 +357,12 @@ class RegisterAllocator
 static inline AnyRegister
 GetFixedRegister(LDefinition *def, const LUse *use)
 {
     return def->type() == LDefinition::DOUBLE
            ? AnyRegister(FloatRegister::FromCode(use->registerCode()))
            : AnyRegister(Register::FromCode(use->registerCode()));
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_RegisterAllocator_h */
--- a/js/src/jit/RegisterSets.h
+++ b/js/src/jit/RegisterSets.h
@@ -8,17 +8,17 @@
 #define jit_RegisterSets_h
 
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/IonAllocPolicy.h"
 #include "jit/Registers.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 struct AnyRegister {
     typedef uint32_t Code;
 
     static const uint32_t Total = Registers::Total + FloatRegisters::Total;
     static const uint32_t Invalid = UINT_MAX;
 
     union {
@@ -786,20 +786,20 @@ class AsmJSHeapAccess
 {
     uint32_t offset_;
 #if defined(JS_CPU_X86)
     uint8_t cmpDelta_;  // the number of bytes from the cmp to the load/store instruction
 #endif
 #if defined(JS_CPU_X86) || defined(JS_CPU_X64)
     uint8_t opLength_;  // the length of the load/store instruction
     uint8_t isFloat32Load_;
-    ion::AnyRegister::Code loadedReg_ : 8;
+    jit::AnyRegister::Code loadedReg_ : 8;
 #endif
 
-    JS_STATIC_ASSERT(ion::AnyRegister::Total < UINT8_MAX);
+    JS_STATIC_ASSERT(jit::AnyRegister::Total < UINT8_MAX);
 
   public:
 #if defined(JS_CPU_X86) || defined(JS_CPU_X64)
     AsmJSHeapAccess(uint32_t offset, uint32_t after, ArrayBufferView::ViewType vt,
                     AnyRegister loadedReg, uint32_t cmp = UINT32_MAX)
       : offset_(offset),
 # if defined(JS_CPU_X86)
         cmpDelta_(offset - cmp),
@@ -828,18 +828,18 @@ class AsmJSHeapAccess
 #if defined(JS_CPU_X86)
     void *patchLengthAt(uint8_t *code) const { return code + (offset_ - cmpDelta_); }
     void *patchOffsetAt(uint8_t *code) const { return code + (offset_ + opLength_); }
 #endif
 #if defined(JS_CPU_X86) || defined(JS_CPU_X64)
     unsigned opLength() const { return opLength_; }
     bool isLoad() const { return loadedReg_ != UINT8_MAX; }
     bool isFloat32Load() const { return isFloat32Load_; }
-    ion::AnyRegister loadedReg() const { return ion::AnyRegister::FromCode(loadedReg_); }
+    jit::AnyRegister loadedReg() const { return jit::AnyRegister::FromCode(loadedReg_); }
 #endif
 };
 
 typedef Vector<AsmJSHeapAccess, 0, IonAllocPolicy> AsmJSHeapAccessVector;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_RegisterSets_h */
--- a/js/src/jit/Registers.h
+++ b/js/src/jit/Registers.h
@@ -20,22 +20,22 @@
 # include "jit/x86/Architecture-x86.h"
 #elif defined(JS_CPU_X64)
 # include "jit/x64/Architecture-x64.h"
 #elif defined(JS_CPU_ARM)
 # include "jit/arm/Architecture-arm.h"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 struct Register {
     typedef Registers Codes;
     typedef Codes::Code Code;
-    typedef js::ion::Registers::RegisterID RegisterID;
+    typedef js::jit::Registers::RegisterID RegisterID;
     Code code_;
 
     static Register FromCode(uint32_t i) {
         JS_ASSERT(i < Registers::Total);
         Register r = { (Registers::Code)i };
         return r;
     }
     Code code() const {
@@ -114,12 +114,12 @@ class MachineState
     double read(FloatRegister reg) const {
         return *fpregs_[reg.code()];
     }
     void write(Register reg, uintptr_t value) const {
         *regs_[reg.code()] = value;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_Registers_h */
--- a/js/src/jit/Safepoints.cpp
+++ b/js/src/jit/Safepoints.cpp
@@ -7,17 +7,17 @@
 #include "jit/Safepoints.h"
 
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/IonSpewer.h"
 #include "jit/LIR.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 using mozilla::FloorLog2;
 
 bool
 SafepointWriter::init(uint32_t slotCount)
 {
     frameSlots_ = BitSet::New(slotCount);
     if (!frameSlots_)
--- a/js/src/jit/Safepoints.h
+++ b/js/src/jit/Safepoints.h
@@ -8,17 +8,17 @@
 #define jit_Safepoints_h
 
 #include "jit/BitSet.h"
 #include "jit/CompactBuffer.h"
 #include "jit/Registers.h"
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 struct SafepointNunboxEntry;
 class LAllocation;
 class LSafepoint;
 
 static const uint32_t INVALID_SAFEPOINT_OFFSET = uint32_t(-1);
 
 class SafepointWriter
@@ -109,12 +109,12 @@ class SafepointReader
     // Returns true if a nunbox slot was read, false if there are no more
     // nunbox slots.
     bool getNunboxSlot(LAllocation *type, LAllocation *payload);
 
     // Returns true if a slot was read, false if there are no more slots.
     bool getSlotsOrElementsSlot(uint32_t *slot);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_Safepoints_h */
--- a/js/src/jit/SnapshotReader.h
+++ b/js/src/jit/SnapshotReader.h
@@ -8,17 +8,17 @@
 #define jit_SnapshotReader_h
 
 #include "jit/CompactBuffer.h"
 #include "jit/IonCode.h"
 #include "jit/IonTypes.h"
 #include "jit/Registers.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 #ifdef TRACK_SNAPSHOTS
 class LInstruction;
 #endif
 
 // A snapshot reader reads the entries out of the compressed snapshot buffer in
 // a script. These entries describe the stack state of an Ion frame at a given
 // position in JIT code.
--- a/js/src/jit/SnapshotWriter.h
+++ b/js/src/jit/SnapshotWriter.h
@@ -9,17 +9,17 @@
 
 #include "jit/Bailouts.h"
 #include "jit/CompactBuffer.h"
 #include "jit/Ion.h"
 #include "jit/IonCode.h"
 #include "jit/Registers.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // Collects snapshots in a contiguous buffer, which is copied into IonScript
 // memory after code generation.
 class SnapshotWriter
 {
     CompactBufferWriter writer_;
 
     // These are only used to assert sanity.
--- a/js/src/jit/Snapshots.cpp
+++ b/js/src/jit/Snapshots.cpp
@@ -13,17 +13,17 @@
 #include "jit/LIR.h"
 #include "jit/MIR.h"
 #endif
 #include "jit/MIRGenerator.h"
 #include "jit/SnapshotReader.h"
 #include "jit/SnapshotWriter.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // Snapshot header:
 //
 //   [vwu] bits (n-31]: frame count
 //         bits [0,n):  bailout kind (n = BAILOUT_KIND_BITS)
 //
 // Snapshot body, repeated "frame count" times, from oldest frame to newest frame.
 // Note that the first frame doesn't have the "parent PC" field.
--- a/js/src/jit/StackSlotAllocator.h
+++ b/js/src/jit/StackSlotAllocator.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_StackSlotAllocator_h
 #define jit_StackSlotAllocator_h
 
 #include "jit/Registers.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class StackSlotAllocator
 {
     js::Vector<uint32_t, 4, SystemAllocPolicy> normalSlots;
     js::Vector<uint32_t, 4, SystemAllocPolicy> doubleSlots;
     uint32_t height_;
 
   public:
@@ -53,12 +53,12 @@ class StackSlotAllocator
     uint32_t allocateValueSlot() {
         return allocateDoubleSlot();
     }
     uint32_t stackHeight() const {
         return height_;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_StackSlotAllocator_h */
--- a/js/src/jit/StupidAllocator.cpp
+++ b/js/src/jit/StupidAllocator.cpp
@@ -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/. */
 
 #include "jit/StupidAllocator.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 static inline uint32_t
 DefaultStackSlot(uint32_t vreg)
 {
 #if JS_BITS_PER_WORD == 32
     return vreg * 2 + 2;
 #else
     return vreg + 1;
--- a/js/src/jit/StupidAllocator.h
+++ b/js/src/jit/StupidAllocator.h
@@ -7,17 +7,17 @@
 #ifndef jit_StupidAllocator_h
 #define jit_StupidAllocator_h
 
 #include "jit/RegisterAllocator.h"
 
 // Simple register allocator that only carries registers within basic blocks.
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class StupidAllocator : public RegisterAllocator
 {
     static const uint32_t MAX_REGISTERS = Registers::Allocatable + FloatRegisters::Allocatable;
     static const uint32_t MISSING_ALLOCATION = UINT32_MAX;
 
     struct AllocatedRegister {
         AnyRegister reg;
@@ -75,12 +75,12 @@ class StupidAllocator : public RegisterA
     void loadRegister(LInstruction *ins, uint32_t vreg, RegisterIndex index);
 
     RegisterIndex findExistingRegister(uint32_t vreg);
 
     bool allocationRequiresRegister(const LAllocation *alloc, AnyRegister reg);
     bool registerIsReserved(LInstruction *ins, AnyRegister reg);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_StupidAllocator_h */
--- a/js/src/jit/TypePolicy.cpp
+++ b/js/src/jit/TypePolicy.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/TypePolicy.h"
 
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 MDefinition *
 BoxInputsPolicy::boxAt(MInstruction *at, MDefinition *operand)
 {
     if (operand->isUnbox())
         return operand->toUnbox()->input();
     MBox *box = MBox::New(operand);
     at->block()->insertBefore(at, box);
--- a/js/src/jit/TypePolicy.h
+++ b/js/src/jit/TypePolicy.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_TypePolicy_h
 #define jit_TypePolicy_h
 
 #include "jit/IonTypes.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MInstruction;
 class MDefinition;
 
 // A type policy directs the type analysis phases, which insert conversion,
 // boxing, unboxing, and type changes as necessary.
 class TypePolicy
 {
@@ -246,12 +246,12 @@ static inline bool
 CoercesToDouble(MIRType type)
 {
     if (type == MIRType_Undefined || type == MIRType_Double)
         return true;
     return false;
 }
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_TypePolicy_h */
--- a/js/src/jit/UnreachableCodeElimination.cpp
+++ b/js/src/jit/UnreachableCodeElimination.cpp
@@ -6,17 +6,17 @@
 
 #include "jit/UnreachableCodeElimination.h"
 
 #include "jit/AliasAnalysis.h"
 #include "jit/IonAnalysis.h"
 #include "jit/ValueNumbering.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 bool
 UnreachableCodeElimination::analyze()
 {
     // The goal of this routine is to eliminate code that is
     // unreachable, either because there is no path from the entry
     // block to the code, or because the path traverses a conditional
     // branch where the condition is a constant (e.g., "if (false) {
--- a/js/src/jit/UnreachableCodeElimination.h
+++ b/js/src/jit/UnreachableCodeElimination.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_UnreachableCodeElimination_h
 #define jit_UnreachableCodeElimination_h
 
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MIRGraph;
 
 class UnreachableCodeElimination
 {
     typedef Vector<MBasicBlock *, 16, SystemAllocPolicy> BlockList;
 
     MIRGenerator *mir_;
@@ -46,12 +46,12 @@ class UnreachableCodeElimination
     bool analyze();
 
     // Removes any blocks that are not marked.  Assumes that these blocks are not
     // reachable.  The parameter |marked| should be the number of blocks that
     // are marked.
     bool removeUnmarkedBlocks(size_t marked);
 };
 
-} /* namespace ion */
+} /* namespace jit */
 } /* namespace js */
 
 #endif /* jit_UnreachableCodeElimination_h */
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -16,20 +16,20 @@
 #include "vm/Debugger.h"
 #include "vm/Interpreter.h"
 
 #include "jit/BaselineFrame-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/StringObject-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 namespace js {
-namespace ion {
+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;
 
 void
 VMFunction::addToFunctions()
 {
@@ -599,17 +599,17 @@ DebugPrologue(JSContext *cx, BaselineFra
       case JSTRAP_CONTINUE:
         return true;
 
       case JSTRAP_RETURN:
         // The script is going to return immediately, so we have to call the
         // debug epilogue handler as well.
         JS_ASSERT(frame->hasReturnValue());
         *mustReturn = true;
-        return ion::DebugEpilogue(cx, frame, true);
+        return jit::DebugEpilogue(cx, frame, true);
 
       case JSTRAP_THROW:
       case JSTRAP_ERROR:
         return false;
 
       default:
         MOZ_ASSUME_UNREACHABLE("Invalid trap status");
     }
@@ -735,17 +735,17 @@ HandleDebugTrap(JSContext *cx, BaselineF
         break;
 
       case JSTRAP_ERROR:
         return false;
 
       case JSTRAP_RETURN:
         *mustReturn = true;
         frame->setReturnValue(rval);
-        return ion::DebugEpilogue(cx, frame, true);
+        return jit::DebugEpilogue(cx, frame, true);
 
       case JSTRAP_THROW:
         cx->setPendingException(rval);
         return false;
 
       default:
         MOZ_ASSUME_UNREACHABLE("Invalid trap status");
     }
@@ -773,17 +773,17 @@ OnDebuggerStatement(JSContext *cx, Basel
         return false;
 
       case JSTRAP_CONTINUE:
         return true;
 
       case JSTRAP_RETURN:
         frame->setReturnValue(rval);
         *mustReturn = true;
-        return ion::DebugEpilogue(cx, frame, true);
+        return jit::DebugEpilogue(cx, frame, true);
 
       case JSTRAP_THROW:
         cx->setPendingException(rval);
         return false;
 
       default:
         MOZ_ASSUME_UNREACHABLE("Invalid trap status");
     }
@@ -803,10 +803,10 @@ LeaveBlock(JSContext *cx, BaselineFrame 
 }
 
 bool
 InitBaselineFrameForOsr(BaselineFrame *frame, StackFrame *interpFrame, uint32_t numStackValues)
 {
     return frame->initForOsr(interpFrame, numStackValues);
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/VMFunctions.h
+++ b/js/src/jit/VMFunctions.h
@@ -13,17 +13,17 @@
 #include "jit/Ion.h"
 #include "jit/IonFrames.h"
 
 namespace js {
 
 class DeclEnvObject;
 class ForkJoinSlice;
 
-namespace ion {
+namespace jit {
 
 enum DataType {
     Type_Void,
     Type_Bool,
     Type_Int32,
     Type_Double,
     Type_Pointer,
     Type_Object,
@@ -655,12 +655,12 @@ bool HandleDebugTrap(JSContext *cx, Base
 bool OnDebuggerStatement(JSContext *cx, BaselineFrame *frame, jsbytecode *pc, bool *mustReturn);
 
 bool EnterBlock(JSContext *cx, BaselineFrame *frame, Handle<StaticBlockObject *> block);
 bool LeaveBlock(JSContext *cx, BaselineFrame *frame);
 
 bool InitBaselineFrameForOsr(BaselineFrame *frame, StackFrame *interpFrame,
                              uint32_t numStackValues);
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_VMFunctions_h */
--- a/js/src/jit/ValueNumbering.cpp
+++ b/js/src/jit/ValueNumbering.cpp
@@ -7,17 +7,17 @@
 #include "jit/ValueNumbering.h"
 
 #include "jit/CompileInfo.h"
 #include "jit/Ion.h"
 #include "jit/IonBuilder.h"
 #include "jit/IonSpewer.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 ValueNumberer::ValueNumberer(MIRGenerator *mir, MIRGraph &graph, bool optimistic)
   : mir(mir),
     graph_(graph),
     pessimisticPass_(!optimistic),
     count_(0)
 { }
 
--- a/js/src/jit/ValueNumbering.h
+++ b/js/src/jit/ValueNumbering.h
@@ -7,17 +7,17 @@
 #ifndef jit_ValueNumbering_h
 #define jit_ValueNumbering_h
 
 #include "jit/CompileInfo.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class ValueNumberer
 {
   protected:
     struct ValueHasher
     {
         typedef MDefinition * Lookup;
         typedef MDefinition * Key;
@@ -128,12 +128,12 @@ class ValueNumberData : public TempObjec
         classPrev = rep;
         classNext = rep->valueNumberData()->classNext;
 
         if (rep->valueNumberData()->classNext)
             rep->valueNumberData()->classNext->valueNumberData()->classPrev = thisDef;
         rep->valueNumberData()->classNext = thisDef;
     }
 };
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_ValueNumbering_h */
--- a/js/src/jit/arm/Architecture-arm.cpp
+++ b/js/src/jit/arm/Architecture-arm.cpp
@@ -24,17 +24,17 @@
 #define HWCAP_VFPv4    (1<<3)
 #define HWCAP_IDIVA    (1<<4)
 #define HWCAP_IDIVT    (1<<5)
 #define HWCAP_NEON     (1<<6)
 #define HWCAP_ARMv7    (1<<7)
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 uint32_t getFlags()
 {
     static bool isSet = false;
     static uint32_t flags = 0;
     if (isSet)
         return flags;
 
@@ -98,40 +98,40 @@ uint32_t getFlags()
     return flags;
 #endif
 
     return false;
 }
 
 bool hasMOVWT()
 {
-    return js::ion::getFlags() & HWCAP_ARMv7;
+    return js::jit::getFlags() & HWCAP_ARMv7;
 }
 bool hasVFPv3()
 {
-    return js::ion::getFlags() & HWCAP_VFPv3;
+    return js::jit::getFlags() & HWCAP_VFPv3;
 }
 bool hasVFP()
 {
-    return js::ion::getFlags() & HWCAP_VFP;
+    return js::jit::getFlags() & HWCAP_VFP;
 }
 
 bool has32DP()
 {
-    return !(js::ion::getFlags() & HWCAP_VFPv3D16 && !(js::ion::getFlags() & HWCAP_NEON));
+    return !(js::jit::getFlags() & HWCAP_VFPv3D16 && !(js::jit::getFlags() & HWCAP_NEON));
 }
 bool useConvReg()
 {
     return has32DP();
 }
 
 bool hasIDIV()
 {
 #if defined HWCAP_IDIVA
-    return js::ion::getFlags() & HWCAP_IDIVA;
+    return js::jit::getFlags() & HWCAP_IDIVA;
 #else
     return false;
 #endif
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
--- a/js/src/jit/arm/Architecture-arm.h
+++ b/js/src/jit/arm/Architecture-arm.h
@@ -10,17 +10,17 @@
 #include <limits.h>
 #include <stdint.h>
 
 // gcc appears to use __ARM_PCS_VFP to denote that the target is a hard-float target.
 #ifdef __ARM_PCS_VFP
 #define JS_CPU_ARM_HARDFP
 #endif
 namespace js {
-namespace ion {
+namespace jit {
 
 static const uint32_t STACK_SLOT_SIZE       = 4;
 static const uint32_t DOUBLE_STACK_ALIGNMENT = 2;
 
 // In bytes: slots needed for potential memory->memory move spills.
 //   +8 for cycles
 //   +4 for gpr spills
 //   +8 for double spills
@@ -210,12 +210,12 @@ class FloatRegisters
 };
 
 bool hasMOVWT();
 bool hasVFPv3();
 bool hasVFP();
 bool has16DP();
 bool hasIDIV();
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_Architecture_arm_h */
--- a/js/src/jit/arm/Assembler-arm.cpp
+++ b/js/src/jit/arm/Assembler-arm.cpp
@@ -13,17 +13,17 @@
 #include "jsutil.h"
 
 #include "assembler/jit/ExecutableAllocator.h"
 #include "gc/Marking.h"
 #include "jit/IonCompartment.h"
 #include "jit/arm/MacroAssembler-arm.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::CountLeadingZeroes32;
 
 ABIArgGenerator::ABIArgGenerator() :
 #if defined(JS_CPU_ARM_HARDFP)
     intRegIndex_(0),
     floatRegIndex_(0),
 #else
@@ -98,147 +98,147 @@ ABIArgGenerator::next(MIRType type)
 #endif
 }
 const Register ABIArgGenerator::NonArgReturnVolatileReg0 = r4;
 const Register ABIArgGenerator::NonArgReturnVolatileReg1 = r5;
 
 // Encode a standard register when it is being used as src1, the dest, and
 // an extra register. These should never be called with an InvalidReg.
 uint32_t
-js::ion::RT(Register r)
+js::jit::RT(Register r)
 {
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 12;
 }
 
 uint32_t
-js::ion::RN(Register r)
+js::jit::RN(Register r)
 {
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 16;
 }
 
 uint32_t
-js::ion::RD(Register r)
+js::jit::RD(Register r)
 {
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 12;
 }
 
 uint32_t
-js::ion::RM(Register r)
+js::jit::RM(Register r)
 {
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 8;
 }
 
 // Encode a standard register when it is being used as src1, the dest, and
 // an extra register.  For these, an InvalidReg is used to indicate a optional
 // register that has been omitted.
 uint32_t
-js::ion::maybeRT(Register r)
+js::jit::maybeRT(Register r)
 {
     if (r == InvalidReg)
         return 0;
 
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 12;
 }
 
 uint32_t
-js::ion::maybeRN(Register r)
+js::jit::maybeRN(Register r)
 {
     if (r == InvalidReg)
         return 0;
 
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 16;
 }
 
 uint32_t
-js::ion::maybeRD(Register r)
+js::jit::maybeRD(Register r)
 {
     if (r == InvalidReg)
         return 0;
 
     JS_ASSERT((r.code() & ~0xf) == 0);
     return r.code() << 12;
 }
 
 Register
-js::ion::toRD(Instruction &i)
+js::jit::toRD(Instruction &i)
 {
     return Register::FromCode((i.encode()>>12) & 0xf);
 }
 Register
-js::ion::toR(Instruction &i)
+js::jit::toR(Instruction &i)
 {
     return Register::FromCode(i.encode() & 0xf);
 }
 
 Register
-js::ion::toRM(Instruction &i)
+js::jit::toRM(Instruction &i)
 {
     return Register::FromCode((i.encode()>>8) & 0xf);
 }
 
 Register
-js::ion::toRN(Instruction &i)
+js::jit::toRN(Instruction &i)
 {
     return Register::FromCode((i.encode()>>16) & 0xf);
 }
 
 uint32_t
-js::ion::VD(VFPRegister vr)
+js::jit::VD(VFPRegister vr)
 {
     if (vr.isMissing())
         return 0;
 
     //bits 15,14,13,12, 22
     VFPRegister::VFPRegIndexSplit s = vr.encode();
     return s.bit << 22 | s.block << 12;
 }
 uint32_t
-js::ion::VN(VFPRegister vr)
+js::jit::VN(VFPRegister vr)
 {
     if (vr.isMissing())
         return 0;
 
     // bits 19,18,17,16, 7
     VFPRegister::VFPRegIndexSplit s = vr.encode();
     return s.bit << 7 | s.block << 16;
 }
 uint32_t
-js::ion::VM(VFPRegister vr)
+js::jit::VM(VFPRegister vr)
 {
     if (vr.isMissing())
         return 0;
 
     // bits 5, 3,2,1,0
     VFPRegister::VFPRegIndexSplit s = vr.encode();
     return s.bit << 5 | s.block;
 }
 
 VFPRegister::VFPRegIndexSplit
-ion::VFPRegister::encode()
+jit::VFPRegister::encode()
 {
     JS_ASSERT(!_isInvalid);
 
     switch (kind) {
       case Double:
         return VFPRegIndexSplit(_code &0xf , _code >> 4);
       case Single:
         return VFPRegIndexSplit(_code >> 1, _code & 1);
       default:
         // vfp register treated as an integer, NOT a gpr
         return VFPRegIndexSplit(_code >> 1, _code & 1);
     }
 }
 
-VFPRegister js::ion::NoVFPRegister(true);
+VFPRegister js::jit::NoVFPRegister(true);
 
 bool
 InstDTR::isTHIS(const Instruction &i)
 {
     return (i.encode() & IsDTRMask) == (uint32_t)IsDTR;
 }
 
 InstDTR *
@@ -543,17 +543,17 @@ Imm16::Imm16(uint32_t imm)
     JS_ASSERT(decode() == imm);
 }
 
 Imm16::Imm16()
   : invalid(0xfff)
 { }
 
 void
-ion::PatchJump(CodeLocationJump &jump_, CodeLocationLabel label)
+jit::PatchJump(CodeLocationJump &jump_, CodeLocationLabel label)
 {
     // We need to determine if this jump can fit into the standard 24+2 bit address
     // or if we need a larger branch (or just need to use our pool entry)
     Instruction *jump = (Instruction*)jump_.raw();
     Assembler::Condition c;
     jump->extractCond(&c);
     JS_ASSERT(jump->is<InstBranchImm>() || jump->is<InstLDR>());
 
@@ -820,30 +820,30 @@ Assembler::TraceJumpRelocations(JSTracer
 }
 
 static void
 TraceDataRelocations(JSTracer *trc, uint8_t *buffer, CompactBufferReader &reader)
 {
     while (reader.more()) {
         size_t offset = reader.readUnsigned();
         InstructionIterator iter((Instruction*)(buffer+offset));
-        void *ptr = const_cast<uint32_t *>(js::ion::Assembler::getPtr32Target(&iter));
+        void *ptr = const_cast<uint32_t *>(js::jit::Assembler::getPtr32Target(&iter));
         // No barrier needed since these are constants.
         gc::MarkGCThingUnbarriered(trc, reinterpret_cast<void **>(&ptr), "ion-masm-ptr");
     }
 
 }
 static void
 TraceDataRelocations(JSTracer *trc, ARMBuffer *buffer,
                      js::Vector<BufferOffset, 0, SystemAllocPolicy> *locs)
 {
     for (unsigned int idx = 0; idx < locs->length(); idx++) {
         BufferOffset bo = (*locs)[idx];
         ARMBuffer::AssemblerBufferInstIterator iter(bo, buffer);
-        void *ptr = const_cast<uint32_t *>(ion::Assembler::getPtr32Target(&iter));
+        void *ptr = const_cast<uint32_t *>(jit::Assembler::getPtr32Target(&iter));
 
         // No barrier needed since these are constants.
         gc::MarkGCThingUnbarriered(trc, reinterpret_cast<void **>(&ptr), "ion-masm-ptr");
     }
 
 }
 void
 Assembler::TraceDataRelocations(JSTracer *trc, IonCode *code, CompactBufferReader &reader)
@@ -1016,17 +1016,17 @@ Imm8::encodeTwoImms(uint32_t imm)
     imm2 = ((imm >> (32 - imm2shift)) | (imm << imm2shift)) & 0xff;
     JS_ASSERT((imm1shift & 0x1) == 0);
     JS_ASSERT((imm2shift & 0x1) == 0);
     return TwoImm8mData(datastore::Imm8mData(imm1, imm1shift >> 1),
                         datastore::Imm8mData(imm2, imm2shift >> 1));
 }
 
 ALUOp
-ion::ALUNeg(ALUOp op, Register dest, Imm32 *imm, Register *negDest)
+jit::ALUNeg(ALUOp op, Register dest, Imm32 *imm, Register *negDest)
 {
     // find an alternate ALUOp to get the job done, and use a different imm.
     *negDest = dest;
     switch (op) {
       case op_mov:
         *imm = Imm32(~imm->value);
         return op_mvn;
       case op_mvn:
@@ -1057,17 +1057,17 @@ ion::ALUNeg(ALUOp op, Register dest, Imm
         return op_bic;
         // orr has orn on thumb2 only.
       default:
         return op_invalid;
     }
 }
 
 bool
-ion::can_dbl(ALUOp op)
+jit::can_dbl(ALUOp op)
 {
     // some instructions can't be processed as two separate instructions
     // such as and, and possibly add (when we're setting ccodes).
     // there is also some hilarity with *reading* condition codes.
     // for example, adc dest, src1, 0xfff; (add with carry) can be split up
     // into adc dest, src1, 0xf00; add dest, dest, 0xff, since "reading" the
     // condition code increments the result by one conditionally, that only needs
     // to be done on one of the two instructions.
@@ -1079,17 +1079,17 @@ ion::can_dbl(ALUOp op)
       case op_orr:
         return true;
       default:
         return false;
     }
 }
 
 bool
-ion::condsAreSafe(ALUOp op) {
+jit::condsAreSafe(ALUOp op) {
     // Even when we are setting condition codes, sometimes we can
     // get away with splitting an operation into two.
     // for example, if our immediate is 0x00ff00ff, and the operation is eors
     // we can split this in half, since x ^ 0x00ff0000 ^ 0x000000ff should
     // set all of its condition codes exactly the same as x ^ 0x00ff00ff.
     // However, if the operation were adds,
     // we cannot split this in half.  If the source on the add is
     // 0xfff00ff0, the result sholud be 0xef10ef, but do we set the overflow bit
@@ -1107,17 +1107,17 @@ ion::condsAreSafe(ALUOp op) {
       case op_eor:
         return true;
       default:
         return false;
     }
 }
 
 ALUOp
-ion::getDestVariant(ALUOp op)
+jit::getDestVariant(ALUOp op)
 {
     // all of the compare operations are dest-less variants of a standard
     // operation.  Given the dest-less variant, return the dest-ful variant.
     switch (op) {
       case op_cmp:
         return op_sub;
       case op_cmn:
         return op_add;
@@ -1126,81 +1126,81 @@ ion::getDestVariant(ALUOp op)
       case op_teq:
         return op_eor;
       default:
         return op;
     }
 }
 
 O2RegImmShift
-ion::O2Reg(Register r) {
+jit::O2Reg(Register r) {
     return O2RegImmShift(r, LSL, 0);
 }
 
 O2RegImmShift
-ion::lsl(Register r, int amt)
+jit::lsl(Register r, int amt)
 {
     JS_ASSERT(0 <= amt && amt <= 31);
     return O2RegImmShift(r, LSL, amt);
 }
 
 O2RegImmShift
-ion::lsr(Register r, int amt)
+jit::lsr(Register r, int amt)
 {
     JS_ASSERT(1 <= amt && amt <= 32);
     return O2RegImmShift(r, LSR, amt);
 }
 
 O2RegImmShift
-ion::ror(Register r, int amt)
+jit::ror(Register r, int amt)
 {
     JS_ASSERT(1 <= amt && amt <= 31);
     return O2RegImmShift(r, ROR, amt);
 }
 O2RegImmShift
-ion::rol(Register r, int amt)
+jit::rol(Register r, int amt)
 {
     JS_ASSERT(1 <= amt && amt <= 31);
     return O2RegImmShift(r, ROR, 32 - amt);
 }
 
 O2RegImmShift
-ion::asr (Register r, int amt)
+jit::asr (Register r, int amt)
 {
     JS_ASSERT(1 <= amt && amt <= 32);
     return O2RegImmShift(r, ASR, amt);
 }
 
 
 O2RegRegShift
-ion::lsl(Register r, Register amt)
+jit::lsl(Register r, Register amt)
 {
     return O2RegRegShift(r, LSL, amt);
 }
 
 O2RegRegShift
-ion::lsr(Register r, Register amt)
+jit::lsr(Register r, Register amt)
 {
     return O2RegRegShift(r, LSR, amt);
 }
 
 O2RegRegShift
-ion::ror(Register r, Register amt)
+jit::ror(Register r, Register amt)
 {
     return O2RegRegShift(r, ROR, amt);
 }
 
 O2RegRegShift
-ion::asr (Register r, Register amt)
+jit::asr (Register r, Register amt)
 {
     return O2RegRegShift(r, ASR, amt);
 }
 
 
-js::ion::VFPImm::VFPImm(uint32_t top)
+js::jit::VFPImm::VFPImm(uint32_t top)
 {
     data = -1;
     datastore::Imm8VFPImmData tmp;
     if (DoubleEncoder::lookup(top, &tmp))
         data = tmp.encode();
 }
 
 BOffImm::BOffImm(Instruction &inst)
@@ -1212,17 +1212,17 @@ Instruction *
 BOffImm::getDest(Instruction *src)
 {
     // TODO: It is probably worthwhile to verify that src is actually a branch
     // NOTE: This does not explicitly shift the offset of the destination left by 2,
     // since it is indexing into an array of instruction sized objects.
     return &src[(((int32_t)data<<8)>>8) + 2];
 }
 
-js::ion::DoubleEncoder js::ion::DoubleEncoder::_this;
+js::jit::DoubleEncoder js::jit::DoubleEncoder::_this;
 
 //VFPRegister implementation
 VFPRegister
 VFPRegister::doubleOverlay()
 {
     JS_ASSERT(!_isInvalid);
     if (kind != Double)
         return VFPRegister(_code >> 1, Double);
--- a/js/src/jit/arm/Assembler-arm.h
+++ b/js/src/jit/arm/Assembler-arm.h
@@ -14,17 +14,17 @@
 #include "assembler/assembler/AssemblerBufferWithConstantPool.h"
 #include "jit/arm/Architecture-arm.h"
 #include "jit/CompactBuffer.h"
 #include "jit/IonCode.h"
 #include "jit/shared/Assembler-shared.h"
 #include "jit/shared/IonAssemblerBufferWithConstantPools.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 //NOTE: there are duplicates in this list!
 // sometimes we want to specifically refer to the
 // link register as a link register (bl lr is much
 // clearer than bl r14).  HOWEVER, this register can
 // easily be a gpr when it is not busy holding the return
 // address.
 static MOZ_CONSTEXPR_VAR Register r0  = { Registers::r0 };
@@ -227,17 +227,17 @@ class VFPRegister
     VFPRegIndexSplit encode();
 
     // for serializing values
     struct VFPRegIndexSplit {
         const uint32_t block : 4;
         const uint32_t bit : 1;
 
       private:
-        friend VFPRegIndexSplit js::ion::VFPRegister::encode();
+        friend VFPRegIndexSplit js::jit::VFPRegister::encode();
 
         VFPRegIndexSplit (uint32_t block_, uint32_t bit_)
           : block(block_), bit(bit_)
         {
             JS_ASSERT (block == block_);
             JS_ASSERT(bit == bit_);
         }
     };
@@ -1117,17 +1117,17 @@ class Operand
         return VFPAddr(baseReg(), VFPOffImm(offset));
     }
 };
 
 void
 PatchJump(CodeLocationJump &jump_, CodeLocationLabel label);
 class InstructionIterator;
 class Assembler;
-typedef js::ion::AssemblerBufferWithConstantPool<1024, 4, Instruction, Assembler, 1> ARMBuffer;
+typedef js::jit::AssemblerBufferWithConstantPool<1024, 4, Instruction, Assembler, 1> ARMBuffer;
 
 class Assembler
 {
   public:
     // ARM conditional constants
     typedef enum {
         EQ = 0x00000000, // Zero
         NE = 0x10000000, // Non-zero
@@ -1262,17 +1262,17 @@ class Assembler
 
     CompactBufferWriter jumpRelocations_;
     CompactBufferWriter dataRelocations_;
     CompactBufferWriter relocations_;
     CompactBufferWriter preBarriers_;
 
     bool enoughMemory_;
 
-    //typedef JSC::AssemblerBufferWithConstantPool<1024, 4, 4, js::ion::Assembler> ARMBuffer;
+    //typedef JSC::AssemblerBufferWithConstantPool<1024, 4, 4, js::jit::Assembler> ARMBuffer;
     ARMBuffer m_buffer;
 
     // There is now a semi-unified interface for instruction generation.
     // During assembly, there is an active buffer that instructions are
     // being written into, but later, we may wish to modify instructions
     // that have already been created.  In order to do this, we call the
     // same assembly function, but pass it a destination address, which
     // will be overwritten with a new instruction. In order to do this very
@@ -2245,12 +2245,12 @@ class AutoForbidPools {
     AutoForbidPools(Assembler *masm) : masm_(masm) {
         masm_->enterNoPool();
     }
     ~AutoForbidPools() {
         masm_->leaveNoPool();
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_Assembler_arm_h */
--- a/js/src/jit/arm/Bailouts-arm.cpp
+++ b/js/src/jit/arm/Bailouts-arm.cpp
@@ -6,17 +6,17 @@
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/Bailouts.h"
 #include "jit/IonCompartment.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 #if 0
 // no clue what these asserts should be.
 JS_STATIC_ASSERT(sizeof(BailoutStack) ==
                  sizeof(uintptr_t) +
                  sizeof(double) * 8 +
                  sizeof(uintptr_t) * 8 +
                  sizeof(uintptr_t));
@@ -57,17 +57,17 @@ IonFramePrefix *
 BailoutEnvironment::top() const
 {
     return (IonFramePrefix *)&frame_[frameSize_ / STACK_SLOT_SIZE];
 }
 
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BailoutStack
 {
     uintptr_t frameClassId_;
     // This is pushed in the bailout handler.  Both entry points into the handler
     // inserts their own value int lr, which is then placed onto the stack along
     // with frameClassId_ above.  This should be migrated to ip.
   public:
@@ -104,17 +104,17 @@ class BailoutStack
     }
     uint8_t *parentStackPointer() const {
         if (frameClass() == FrameSizeClass::None())
             return (uint8_t *)this + sizeof(BailoutStack);
         return (uint8_t *)this + offsetof(BailoutStack, snapshotOffset_);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
                                        BailoutStack *bailout)
   : IonFrameIterator(activations),
     machine_(bailout->machine())
 {
     uint8_t *sp = bailout->parentStackPointer();
--- a/js/src/jit/arm/BaselineCompiler-arm.cpp
+++ b/js/src/jit/arm/BaselineCompiler-arm.cpp
@@ -2,14 +2,14 @@
  * 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/arm/BaselineCompiler-arm.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BaselineCompilerARM::BaselineCompilerARM(JSContext *cx, HandleScript script)
   : BaselineCompilerShared(cx, script)
 {
 }
--- a/js/src/jit/arm/BaselineCompiler-arm.h
+++ b/js/src/jit/arm/BaselineCompiler-arm.h
@@ -5,22 +5,22 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_BaselineCompiler_arm_h
 #define jit_arm_BaselineCompiler_arm_h
 
 #include "jit/shared/BaselineCompiler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BaselineCompilerARM : public BaselineCompilerShared
 {
   protected:
     BaselineCompilerARM(JSContext *cx, HandleScript script);
 };
 
 typedef BaselineCompilerARM BaselineCompilerSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_BaselineCompiler_arm_h */
--- a/js/src/jit/arm/BaselineHelpers-arm.h
+++ b/js/src/jit/arm/BaselineHelpers-arm.h
@@ -9,17 +9,17 @@
 
 #ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+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
 EmitRestoreTailCallReg(MacroAssembler &masm)
 {
     // No-op on ARM because link register is always holding the return address.
@@ -296,15 +296,15 @@ EmitStubGuardFailure(MacroAssembler &mas
     masm.loadPtr(Address(BaselineStubReg, ICStub::offsetOfStubCode()), r0);
 
     // Return address is already loaded, just jump to the next stubcode.
     JS_ASSERT(BaselineTailCallReg == lr);
     masm.branch(r0);
 }
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_arm_BaselineHelpers_arm_h */
 
--- a/js/src/jit/arm/BaselineIC-arm.cpp
+++ b/js/src/jit/arm/BaselineIC-arm.cpp
@@ -6,20 +6,20 @@
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/IonLinker.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // ICCompare_Int32
 
 bool
 ICCompare_Int32::Compiler::generateStubCode(MacroAssembler &masm)
 {
     // Guard that R0 is an integer and R1 is an integer.
     Label failure;
@@ -252,10 +252,10 @@ ICUnaryArith_Int32::Compiler::generateSt
 
     EmitReturnFromIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/arm/BaselineRegisters-arm.h
+++ b/js/src/jit/arm/BaselineRegisters-arm.h
@@ -7,17 +7,17 @@
 #ifndef jit_arm_BaselineRegisters_arm_h
 #define jit_arm_BaselineRegisters_arm_h
 
 #ifdef JS_ION
 
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // r15 = program-counter
 // r14 = link-register
 
 // r13 = stack-pointer
 // r11 = frame-pointer
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = r11;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = sp;
@@ -47,14 +47,14 @@ static MOZ_CONSTEXPR_VAR Register Baseli
 // Note that BaselineTailCallReg is actually just the link
 // register.  In ARM code emission, we do not clobber BaselineTailCallReg
 // since we keep the return address for calls there.
 
 // FloatReg0 must be equal to ReturnFloatReg. d1 is ScratchFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = d0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = d2;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_arm_BaselineRegisters_arm_h */
--- a/js/src/jit/arm/CodeGenerator-arm.cpp
+++ b/js/src/jit/arm/CodeGenerator-arm.cpp
@@ -21,17 +21,17 @@
 #include "vm/Shape.h"
 
 #include "jsscriptinlines.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::FloorLog2;
 
 // shared
 CodeGeneratorARM::CodeGeneratorARM(MIRGenerator *gen, LIRGraph *graph, MacroAssembler *masm)
   : CodeGeneratorShared(gen, graph, masm)
 {
 }
@@ -1004,17 +1004,17 @@ CodeGeneratorARM::toMoveOperand(const LA
     // The way the stack slots work, we assume that everything from depth == 0 downwards is writable
     // however, since our frame is included in this, ensure that the frame gets skipped
     if (gen->compilingAsmJS())
         offset -= AlignmentMidPrologue;
 
     return MoveOperand(StackPointer, offset);
 }
 
-class js::ion::OutOfLineTableSwitch : public OutOfLineCodeBase<CodeGeneratorARM>
+class js::jit::OutOfLineTableSwitch : public OutOfLineCodeBase<CodeGeneratorARM>
 {
     MTableSwitch *mir_;
     Vector<CodeLabel, 8, IonAllocPolicy> codeLabels_;
 
     bool accept(CodeGeneratorARM *codegen) {
         return codegen->visitOutOfLineTableSwitch(this);
     }
 
--- a/js/src/jit/arm/CodeGenerator-arm.h
+++ b/js/src/jit/arm/CodeGenerator-arm.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_arm_CodeGenerator_arm_h
 #define jit_arm_CodeGenerator_arm_h
 
 #include "jit/arm/Assembler-arm.h"
 #include "jit/shared/CodeGenerator-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class OutOfLineBailout;
 class OutOfLineTableSwitch;
 
 class CodeGeneratorARM : public CodeGeneratorShared
 {
     friend class MoveResolverARM;
 
@@ -194,12 +194,12 @@ class OutOfLineBailout : public OutOfLin
 
     bool accept(CodeGeneratorARM *codegen);
 
     LSnapshot *snapshot() const {
         return snapshot_;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_CodeGenerator_arm_h */
--- a/js/src/jit/arm/IonFrames-arm.cpp
+++ b/js/src/jit/arm/IonFrames-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/Ion.h"
 #include "jit/IonFrames.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 IonJSFrameLayout *
 InvalidationBailoutStack::fp() const
 {
     return (IonJSFrameLayout *) (sp() + ionScript_->frameSize());
 }
 
 void
--- a/js/src/jit/arm/IonFrames-arm.h
+++ b/js/src/jit/arm/IonFrames-arm.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_IonFrames_arm_h
 #define jit_arm_IonFrames_arm_h
 
 #include "jit/shared/IonFrames-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class IonFramePrefix;
 // 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
 {
     uint8_t *returnAddress_;
     uintptr_t descriptor_;
@@ -531,12 +531,12 @@ class InvalidationBailoutStack
     }
     uint8_t *osiPointReturnAddress() const {
         return osiPointReturnAddress_;
     }
 
     void checkInvariants() const;
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_IonFrames_arm_h */
--- a/js/src/jit/arm/LIR-arm.h
+++ b/js/src/jit/arm/LIR-arm.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_arm_LIR_arm_h
 #define jit_arm_LIR_arm_h
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LBox : public LInstructionHelper<2, 1, 0>
 {
     MIRType type_;
 
   public:
     LIR_HEADER(Box);
 
@@ -404,12 +404,12 @@ class LAsmJSLoadFuncPtr : public LInstru
     const LAllocation *index() {
         return getOperand(0);
     }
     const LDefinition *temp() {
         return getTemp(0);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_LIR_arm_h */
--- a/js/src/jit/arm/Lowering-arm.cpp
+++ b/js/src/jit/arm/Lowering-arm.cpp
@@ -8,17 +8,17 @@
 
 #include "jit/arm/Assembler-arm.h"
 #include "jit/Lowering.h"
 #include "jit/MIR.h"
 
 #include "jit/shared/Lowering-shared-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::FloorLog2;
 
 bool
 LIRGeneratorARM::useBox(LInstruction *lir, size_t n, MDefinition *mir,
                         LUse::Policy policy, bool useAtStart)
 {
     JS_ASSERT(mir->type() == MIRType_Value);
--- a/js/src/jit/arm/Lowering-arm.h
+++ b/js/src/jit/arm/Lowering-arm.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_Lowering_arm_h
 #define jit_arm_Lowering_arm_h
 
 #include "jit/shared/Lowering-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LIRGeneratorARM : public LIRGeneratorShared
 {
   public:
     LIRGeneratorARM(MIRGenerator *gen, MIRGraph &graph, LIRGraph &lirGraph)
       : LIRGeneratorShared(gen, graph, lirGraph)
     { }
 
@@ -81,12 +81,12 @@ class LIRGeneratorARM : public LIRGenera
     bool visitAsmJSStoreHeap(MAsmJSStoreHeap *ins);
     bool visitAsmJSLoadFuncPtr(MAsmJSLoadFuncPtr *ins);
     bool visitInterruptCheck(MInterruptCheck *ins);
     bool visitStoreTypedArrayElementStatic(MStoreTypedArrayElementStatic *ins);
 };
 
 typedef LIRGeneratorARM LIRGeneratorSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_Lowering_arm_h */
--- a/js/src/jit/arm/MacroAssembler-arm.cpp
+++ b/js/src/jit/arm/MacroAssembler-arm.cpp
@@ -8,17 +8,17 @@
 
 #include "mozilla/DebugOnly.h"
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/BaselineFrame.h"
 #include "jit/MoveEmitter.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 using mozilla::Abs;
 
 bool
 isValueDTRDCandidate(ValueOperand &val)
 {
     // In order to be used for a DTRD memory function, the two target registers
     // need to be a) Adjacent, with the tag larger than the payload, and
--- a/js/src/jit/arm/MacroAssembler-arm.h
+++ b/js/src/jit/arm/MacroAssembler-arm.h
@@ -14,17 +14,17 @@
 #include "jit/arm/Assembler-arm.h"
 #include "jit/IonCaches.h"
 #include "jit/IonFrames.h"
 #include "jit/MoveResolver.h"
 
 using mozilla::DebugOnly;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static Register CallReg = ip;
 static const int defaultShift = 3;
 JS_STATIC_ASSERT(1 << defaultShift == sizeof(jsval));
 
 // MacroAssemblerARM is inheriting form Assembler defined in Assembler-arm.{h,cpp}
 class MacroAssemblerARM : public Assembler
 {
@@ -1371,12 +1371,12 @@ class MacroAssemblerARMCompat : public M
         as_vcvt(VFPRegister(ScratchFloatReg).singleOverlay(), src, false, cond);
         ma_vstr(VFPRegister(ScratchFloatReg).singleOverlay(), base, index, 0, cond);
 
     }
 };
 
 typedef MacroAssemblerARMCompat MacroAssemblerSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_MacroAssembler_arm_h */
--- a/js/src/jit/arm/MoveEmitter-arm.cpp
+++ b/js/src/jit/arm/MoveEmitter-arm.cpp
@@ -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/. */
 
 #include "jit/arm/MoveEmitter-arm.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 MoveEmitterARM::MoveEmitterARM(MacroAssemblerARMCompat &masm)
   : inCycle_(false),
     masm(masm),
     pushedAtCycle_(-1),
     pushedAtSpill_(-1),
     spilledReg_(InvalidReg),
     spilledFloatReg_(InvalidFloatReg)
--- a/js/src/jit/arm/MoveEmitter-arm.h
+++ b/js/src/jit/arm/MoveEmitter-arm.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_arm_MoveEmitter_arm_h
 #define jit_arm_MoveEmitter_arm_h
 
 #include "jit/IonMacroAssembler.h"
 #include "jit/MoveResolver.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class CodeGenerator;
 
 class MoveEmitterARM
 {
     typedef MoveResolver::Move Move;
     typedef MoveResolver::MoveOperand MoveOperand;
 
@@ -57,12 +57,12 @@ class MoveEmitterARM
     MoveEmitterARM(MacroAssemblerARMCompat &masm);
     ~MoveEmitterARM();
     void emit(const MoveResolver &moves);
     void finish();
 };
 
 typedef MoveEmitterARM MoveEmitter;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_arm_MoveEmitter_arm_h */
--- a/js/src/jit/arm/Trampoline-arm.cpp
+++ b/js/src/jit/arm/Trampoline-arm.cpp
@@ -12,17 +12,17 @@
 #include "jit/ExecutionModeInlines.h"
 #include "jit/IonCompartment.h"
 #include "jit/IonFrames.h"
 #include "jit/IonLinker.h"
 #include "jit/IonSpewer.h"
 #include "jit/VMFunctions.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 static void
 GenerateReturn(MacroAssembler &masm, int returnCode)
 {
     // Restore non-volatile registers
     masm.ma_mov(Imm32(returnCode), r0);
     masm.startDataTransferM(IsLoad, sp, IA, WriteBack);
     masm.transferReg(r4);
@@ -228,17 +228,17 @@ IonRuntime::generateEnterJIT(JSContext *
 
         masm.push(framePtr); // BaselineFrame
         masm.push(r0); // jitcode
 
         masm.setupUnalignedABICall(3, scratch);
         masm.passABIArg(r11); // BaselineFrame
         masm.passABIArg(OsrFrameReg); // StackFrame
         masm.passABIArg(numStackValues);
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, ion::InitBaselineFrameForOsr));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, jit::InitBaselineFrameForOsr));
 
         Register jitcode = regs.takeAny();
         masm.pop(jitcode);
         masm.pop(framePtr);
 
         JS_ASSERT(jitcode != ReturnReg);
 
         Label error;
--- a/js/src/jit/shared/Assembler-shared.h
+++ b/js/src/jit/shared/Assembler-shared.h
@@ -16,17 +16,17 @@
 #include "jit/RegisterSets.h"
 
 #if defined(JS_CPU_X64) || defined(JS_CPU_ARM)
 // JS_SMALL_BRANCH means the range on a branch instruction
 // is smaller than the whole address space
 #    define JS_SMALL_BRANCH
 #endif
 namespace js {
-namespace ion {
+namespace jit {
 
 enum Scale {
     TimesOne = 0,
     TimesTwo = 1,
     TimesFour = 2,
     TimesEight = 3
 };
 
@@ -566,12 +566,12 @@ class CodeLocationLabel
     }
     uint8_t *offset() const {
         JS_ASSERT(state_ == Relative);
         return raw_;
     }
 };
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_Assembler_shared_h */
--- a/js/src/jit/shared/Assembler-x86-shared.cpp
+++ b/js/src/jit/shared/Assembler-x86-shared.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 "gc/Marking.h"
 #include "jit/IonMacroAssembler.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 void
 AssemblerX86Shared::copyJumpRelocationTable(uint8_t *dest)
 {
     if (jumpRelocations_.length())
         memcpy(dest, jumpRelocations_.buffer(), jumpRelocations_.length());
 }
 
--- a/js/src/jit/shared/Assembler-x86-shared.h
+++ b/js/src/jit/shared/Assembler-x86-shared.h
@@ -8,17 +8,17 @@
 #define jit_shared_Assembler_x86_shared_h
 
 #include <cstddef>
 
 #include "assembler/assembler/X86Assembler.h"
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class AssemblerX86Shared
 {
   protected:
     struct RelativePatch {
         int32_t offset;
         void *target;
         Relocation::Kind kind;
@@ -1390,12 +1390,12 @@ class AssemblerX86Shared
     static void ToggleCall(CodeLocationLabel inst, bool enabled) {
         uint8_t *ptr = (uint8_t *)inst.raw();
         JS_ASSERT(*ptr == 0x3D || // CMP
                   *ptr == 0xE8);  // CALL
         *ptr = enabled ? 0xE8 : 0x3D;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_Assembler_x86_shared_h */
--- a/js/src/jit/shared/BaselineCompiler-shared.cpp
+++ b/js/src/jit/shared/BaselineCompiler-shared.cpp
@@ -5,24 +5,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/shared/BaselineCompiler-shared.h"
 
 #include "jit/BaselineIC.h"
 #include "jit/VMFunctions.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BaselineCompilerShared::BaselineCompilerShared(JSContext *cx, HandleScript script)
   : cx(cx),
     script(cx, script),
     pc(script->code),
-    ionCompileable_(ion::IsEnabled(cx) && CanIonCompileScript(cx, script, false)),
-    ionOSRCompileable_(ion::IsEnabled(cx) && CanIonCompileScript(cx, script, true)),
+    ionCompileable_(jit::IsIonEnabled(cx) && CanIonCompileScript(cx, script, false)),
+    ionOSRCompileable_(jit::IsIonEnabled(cx) && CanIonCompileScript(cx, script, true)),
     debugMode_(cx->compartment()->debugMode()),
     analysis_(script),
     frame(cx, script, masm),
     stubSpace_(),
     icEntries_(),
     pcMappingEntries_(),
     icLoadLabels_(),
     pushedBeforeCall_(0),
--- a/js/src/jit/shared/BaselineCompiler-shared.h
+++ b/js/src/jit/shared/BaselineCompiler-shared.h
@@ -11,17 +11,17 @@
 
 #include "jit/BaselineFrameInfo.h"
 #include "jit/BaselineIC.h"
 #include "jit/IonInstrumentation.h"
 #include "jit/IonMacroAssembler.h"
 #include "jit/IonSpewer.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BaselineCompilerShared
 {
   protected:
     JSContext *cx;
     RootedScript script;
     jsbytecode *pc;
     MacroAssembler masm;
@@ -133,12 +133,12 @@ class BaselineCompilerShared
     bool callVM(const VMFunction &fun);
 
   public:
     BytecodeAnalysis &analysis() {
         return analysis_;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_BaselineCompiler_shared_h */
--- a/js/src/jit/shared/BaselineCompiler-x86-shared.cpp
+++ b/js/src/jit/shared/BaselineCompiler-x86-shared.cpp
@@ -2,14 +2,14 @@
  * 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/BaselineCompiler-x86-shared.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BaselineCompilerX86Shared::BaselineCompilerX86Shared(JSContext *cx, HandleScript script)
   : BaselineCompilerShared(cx, script)
 {
 }
--- a/js/src/jit/shared/BaselineCompiler-x86-shared.h
+++ b/js/src/jit/shared/BaselineCompiler-x86-shared.h
@@ -5,20 +5,20 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_shared_BaselineCompiler_x86_shared_h
 #define jit_shared_BaselineCompiler_x86_shared_h
 
 #include "jit/shared/BaselineCompiler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BaselineCompilerX86Shared : public BaselineCompilerShared
 {
   protected:
     BaselineCompilerX86Shared(JSContext *cx, HandleScript script);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_BaselineCompiler_x86_shared_h */
--- a/js/src/jit/shared/BaselineIC-x86-shared.cpp
+++ b/js/src/jit/shared/BaselineIC-x86-shared.cpp
@@ -6,17 +6,17 @@
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/IonLinker.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 bool
 ICCompare_Double::Compiler::generateStubCode(MacroAssembler &masm)
 {
     Label failure, notNaN;
     masm.ensureDouble(R0, FloatReg0, &failure);
     masm.ensureDouble(R1, FloatReg1, &failure);
 
--- a/js/src/jit/shared/CodeGenerator-shared-inl.h
+++ b/js/src/jit/shared/CodeGenerator-shared-inl.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_shared_CodeGenerator_shared_inl_h
 #define jit_shared_CodeGenerator_shared_inl_h
 
 #include "jit/shared/CodeGenerator-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static inline int32_t
 ToInt32(const LAllocation *a)
 {
     if (a->isConstantValue())
         return a->toConstant()->toInt32();
     if (a->isConstantIndex())
         return a->toConstantIndex()->index();
--- a/js/src/jit/shared/CodeGenerator-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-shared.cpp
@@ -13,22 +13,22 @@
 #include "jit/IonSpewer.h"
 #include "jit/MIR.h"
 #include "jit/MIRGenerator.h"
 #include "jit/ParallelFunctions.h"
 
 #include "jit/IonFrames-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::DebugOnly;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 MacroAssembler &
 CodeGeneratorShared::ensureMasm(MacroAssembler *masmArg)
 {
     if (masmArg)
         return *masmArg;
     maybeMasm_.construct();
     return maybeMasm_.ref();
@@ -671,10 +671,10 @@ CodeGeneratorShared::callTraceLIR(uint32
     masm.passABIArg(mirOpNameReg);
     masm.passABIArg(scriptReg);
     masm.passABIArg(pcReg);
     masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, TraceLIR));
     masm.PopRegsInMask(RegisterSet::All());
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/shared/CodeGenerator-shared.h
+++ b/js/src/jit/shared/CodeGenerator-shared.h
@@ -13,17 +13,17 @@
 #include "jit/LIR.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 #include "jit/Safepoints.h"
 #include "jit/SnapshotWriter.h"
 #include "jit/VMFunctions.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class OutOfLineCode;
 class CodeGenerator;
 class MacroAssembler;
 class IonCache;
 class OutOfLineAbortPar;
 class OutOfLinePropagateAbortPar;
 
@@ -681,12 +681,12 @@ class OutOfLinePropagateAbortPar : publi
       : lir_(lir)
     { }
 
     LInstruction *lir() { return lir_; }
 
     bool generate(CodeGeneratorShared *codegen);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_CodeGenerator_shared_h */
--- a/js/src/jit/shared/CodeGenerator-x86-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-x86-shared.cpp
@@ -16,22 +16,22 @@
 #include "jit/IonCompartment.h"
 #include "jit/IonFrames.h"
 #include "jit/ParallelFunctions.h"
 #include "jit/RangeAnalysis.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::FloorLog2;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 CodeGeneratorX86Shared::CodeGeneratorX86Shared(MIRGenerator *gen, LIRGraph *graph, MacroAssembler *masm)
   : CodeGeneratorShared(gen, graph, masm)
 {
 }
 
 bool
 CodeGeneratorX86Shared::generatePrologue()
@@ -1509,10 +1509,10 @@ CodeGeneratorX86Shared::visitNegD(LNegD 
     FloatRegister input = ToFloatRegister(ins->input());
     JS_ASSERT(input == ToFloatRegister(ins->output()));
 
     masm.negateDouble(input);
     return true;
 }
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/shared/CodeGenerator-x86-shared.h
+++ b/js/src/jit/shared/CodeGenerator-x86-shared.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_shared_CodeGenerator_x86_shared_h
 #define jit_shared_CodeGenerator_x86_shared_h
 
 #include "jit/shared/CodeGenerator-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class OutOfLineBailout;
 class OutOfLineUndoALUOperation;
 class MulNegativeZeroCheck;
 class ModOverflowCheck;
 class ReturnZero;
 class OutOfLineTableSwitch;
 
@@ -138,12 +138,12 @@ class OutOfLineBailout : public OutOfLin
 
     bool accept(CodeGeneratorX86Shared *codegen);
 
     LSnapshot *snapshot() const {
         return snapshot_;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_CodeGenerator_x86_shared_h */
--- a/js/src/jit/shared/IonAssemblerBuffer.h
+++ b/js/src/jit/shared/IonAssemblerBuffer.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_shared_IonAssemblerBuffer_h
 #define jit_shared_IonAssemblerBuffer_h
 
 // needed for the definition of Label :(
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // This should theoretically reside inside of AssemblerBuffer, but that won't be nice
 // AssemblerBuffer is templated, BufferOffset would be indirectly.
 // A BufferOffset is the offset into a buffer, expressed in bytes of instructions.
 
 class BufferOffset
 {
     int offset;
--- a/js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
+++ b/js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
@@ -7,17 +7,17 @@
 #ifndef jit_shared_IonAssemblerBufferWithConstantPools_h
 #define jit_shared_IonAssemblerBufferWithConstantPools_h
 
 #include "assembler/wtf/SegmentedVector.h"
 #include "jit/IonSpewer.h"
 #include "jit/shared/IonAssemblerBuffer.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 typedef Vector<BufferOffset, 512, IonAllocPolicy> LoadOffsets;
 
 struct Pool
   : public IonAllocPolicy
 {
     const int maxOffset;
     const int immSize;
     const int instSize;
--- a/js/src/jit/shared/IonFrames-x86-shared.cpp
+++ b/js/src/jit/shared/IonFrames-x86-shared.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/Ion.h"
 #include "jit/IonFrames.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 IonJSFrameLayout *
 InvalidationBailoutStack::fp() const
 {
     return (IonJSFrameLayout *) (sp() + ionScript_->frameSize());
 }
 
 void
--- a/js/src/jit/shared/IonFrames-x86-shared.h
+++ b/js/src/jit/shared/IonFrames-x86-shared.h
@@ -7,17 +7,17 @@
 #ifndef jit_shared_IonFrames_x86_shared_h
 #define jit_shared_IonFrames_x86_shared_h
 
 #include <stdint.h>
 
 #include "jit/shared/IonFrames-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class IonCommonFrameLayout
 {
   private:
     uint8_t *returnAddress_;
     uintptr_t descriptor_;
 
     static const uintptr_t FrameTypeMask = (1 << FRAMETYPE_BITS) - 1;
--- a/js/src/jit/shared/LIR-x86-shared.h
+++ b/js/src/jit/shared/LIR-x86-shared.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_shared_LIR_x86_shared_h
 #define jit_shared_LIR_x86_shared_h
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LDivI : public LBinaryMath<1>
 {
   public:
     LIR_HEADER(DivI)
 
     LDivI(const LAllocation &lhs, const LAllocation &rhs, const LDefinition &temp) {
         setOperand(0, lhs);
@@ -272,12 +272,12 @@ class LMulI : public LBinaryMath<0, 1>
     MMul *mir() const {
         return mir_->toMul();
     }
     const LAllocation *lhsCopy() {
         return this->getOperand(2);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_LIR_x86_shared_h */
--- a/js/src/jit/shared/Lowering-shared-inl.h
+++ b/js/src/jit/shared/Lowering-shared-inl.h
@@ -8,17 +8,17 @@
 #define jit_shared_Lowering_shared_inl_h
 
 #include "jit/shared/Lowering-shared.h"
 
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 bool
 LIRGeneratorShared::emitAtUses(MInstruction *mir)
 {
     JS_ASSERT(mir->canEmitAtUses());
     mir->setEmittedAtUses();
     mir->setVirtualRegister(0);
     return true;
@@ -451,12 +451,12 @@ LIRGeneratorShared::fillBoxUses(LInstruc
     if (!ensureDefined(mir))
         return false;
     lir->getOperand(n)->toUse()->setVirtualRegister(mir->virtualRegister() + VREG_TYPE_OFFSET);
     lir->getOperand(n + 1)->toUse()->setVirtualRegister(VirtualRegisterOfPayload(mir));
     return true;
 }
 #endif
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_Lowering_shared_inl_h */
--- a/js/src/jit/shared/Lowering-shared.cpp
+++ b/js/src/jit/shared/Lowering-shared.cpp
@@ -6,17 +6,17 @@
 
 #include "jit/shared/Lowering-shared-inl.h"
 
 #include "jit/LIR.h"
 #include "jit/MIR.h"
 #include "jit/MIRGraph.h"
 
 using namespace js;
-using namespace ion;
+using namespace jit;
 
 bool
 LIRGeneratorShared::visitConstant(MConstant *ins)
 {
     const Value &v = ins->value();
     switch (ins->type()) {
       case MIRType_Boolean:
         return define(new LInteger(v.toBoolean()), ins);
--- a/js/src/jit/shared/Lowering-shared.h
+++ b/js/src/jit/shared/Lowering-shared.h
@@ -9,17 +9,17 @@
 
 // This file declares the structures that are used for attaching LIR to a
 // MIRGraph.
 
 #include "jit/IonAllocPolicy.h"
 #include "jit/LIR.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MBasicBlock;
 class MTableSwitch;
 class MIRGenerator;
 class MIRGraph;
 class MDefinition;
 class MInstruction;
 class LOsiPoint;
@@ -177,12 +177,12 @@ class LIRGeneratorShared : public MInstr
     }
 
     // Whether to generate typed array accesses on statically known objects.
     static bool allowStaticTypedArrayAccesses() {
         return false;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_Lowering_shared_h */
--- a/js/src/jit/shared/Lowering-x86-shared.cpp
+++ b/js/src/jit/shared/Lowering-x86-shared.cpp
@@ -9,17 +9,17 @@
 #include "mozilla/MathAlgorithms.h"
 
 #include "jit/Lowering.h"
 #include "jit/MIR.h"
 
 #include "jit/shared/Lowering-shared-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 using mozilla::FloorLog2;
 
 LTableSwitch *
 LIRGeneratorX86Shared::newLTableSwitch(const LAllocation &in, const LDefinition &inputCopy,
                                        MTableSwitch *tableswitch)
 {
     return new LTableSwitch(in, inputCopy, temp(), tableswitch);
--- a/js/src/jit/shared/Lowering-x86-shared.h
+++ b/js/src/jit/shared/Lowering-x86-shared.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_shared_Lowering_x86_shared_h
 #define jit_shared_Lowering_x86_shared_h
 
 #include "jit/shared/Lowering-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LIRGeneratorX86Shared : public LIRGeneratorShared
 {
   protected:
     LIRGeneratorX86Shared(MIRGenerator *gen, MIRGraph &graph, LIRGraph &lirGraph)
       : LIRGeneratorShared(gen, graph, lirGraph)
     {}
 
@@ -45,12 +45,12 @@ class LIRGeneratorX86Shared : public LIR
     bool lowerModI(MMod *mod);
     bool lowerUDiv(MInstruction *div);
     bool lowerUMod(MInstruction *mod);
     bool lowerUrshD(MUrsh *mir);
     bool lowerConstantDouble(double d, MInstruction *ins);
     bool lowerTruncateDToInt32(MTruncateToInt32 *ins);
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_Lowering_x86_shared_h */
--- a/js/src/jit/shared/MacroAssembler-x86-shared.h
+++ b/js/src/jit/shared/MacroAssembler-x86-shared.h
@@ -16,17 +16,17 @@
 #include "jit/IonFrames.h"
 #if defined(JS_CPU_X86)
 # include "jit/x86/Assembler-x86.h"
 #elif defined(JS_CPU_X64)
 # include "jit/x64/Assembler-x64.h"
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class MacroAssemblerX86Shared : public Assembler
 {
   protected:
     // Bytes pushed onto the frame by the callee; includes frameDepth_. This is
     // needed to compute offsets to stack slots while temporary space has been
     // reserved for unexpected spills or C++ function calls. It is maintained
     // by functions which track stack alignment, which for clear distinction
@@ -505,12 +505,12 @@ class MacroAssemblerX86Shared : public A
         return CodeOffsetLabel(size());
     }
     
     void abiret() {
         ret();
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_shared_MacroAssembler_x86_shared_h */
--- a/js/src/jit/shared/MoveEmitter-x86-shared.cpp
+++ b/js/src/jit/shared/MoveEmitter-x86-shared.cpp
@@ -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/. */
 
 #include "jit/shared/MoveEmitter-x86-shared.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 MoveEmitterX86::MoveEmitterX86(MacroAssemblerSpecific &masm)
   : inCycle_(false),
     masm(masm),
     pushedAtCycle_(-1)
 {
     pushedAtStart_ = masm.framePushed();
 }
--- a/js/src/jit/shared/MoveEmitter-x86-shared.h
+++ b/js/src/jit/shared/MoveEmitter-x86-shared.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_MoveEmitter_x86_shared_h
 #define jit_MoveEmitter_x86_shared_h
 
 #include "jit/IonMacroAssembler.h"
 #include "jit/MoveResolver.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class CodeGenerator;
 
 class MoveEmitterX86
 {
     typedef MoveResolver::Move Move;
     typedef MoveResolver::MoveOperand MoveOperand;
 
--- a/js/src/jit/x64/Architecture-x64.h
+++ b/js/src/jit/x64/Architecture-x64.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_Architecture_x64_h
 #define jit_x64_Architecture_x64_h
 
 #include "assembler/assembler/MacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static const ptrdiff_t STACK_SLOT_SIZE       = 8;
 static const uint32_t MAX_STACK_SLOTS          = 256;
 static const uint32_t DOUBLE_STACK_ALIGNMENT   = 1;
 
 // In bytes: slots needed for potential memory->memory move spills.
 //   +8 for cycles
 //   +8 for gpr spills
@@ -149,12 +149,12 @@ class FloatRegisters {
     static const uint32_t WrapperMask = VolatileMask;
 
     static const uint32_t NonAllocatableMask =
         (1 << JSC::X86Registers::xmm15);    // This is ScratchFloatReg.
 
     static const uint32_t AllocatableMask = AllMask & ~NonAllocatableMask;
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_Architecture_x64_h */
--- a/js/src/jit/x64/Assembler-x64.cpp
+++ b/js/src/jit/x64/Assembler-x64.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jit/x64/Assembler-x64.h"
 
 #include "gc/Marking.h"
 #include "jit/LIR.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 ABIArgGenerator::ABIArgGenerator()
   :
 #if defined(XP_WIN)
     regIndex_(0),
     stackOffset_(ShadowStackSpace),
 #else
     intRegIndex_(0),
--- a/js/src/jit/x64/Assembler-x64.h
+++ b/js/src/jit/x64/Assembler-x64.h
@@ -9,17 +9,17 @@
 
 #include "mozilla/Util.h"
 
 #include "jit/CompactBuffer.h"
 #include "jit/IonCode.h"
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register rax = { JSC::X86Registers::eax };
 static MOZ_CONSTEXPR_VAR Register rbx = { JSC::X86Registers::ebx };
 static MOZ_CONSTEXPR_VAR Register rcx = { JSC::X86Registers::ecx };
 static MOZ_CONSTEXPR_VAR Register rdx = { JSC::X86Registers::edx };
 static MOZ_CONSTEXPR_VAR Register rsi = { JSC::X86Registers::esi };
 static MOZ_CONSTEXPR_VAR Register rdi = { JSC::X86Registers::edi };
 static MOZ_CONSTEXPR_VAR Register rbp = { JSC::X86Registers::ebp };
@@ -252,23 +252,23 @@ class Operand
         return (FloatRegisters::Code)base_;
     }
     int32_t disp() const {
         JS_ASSERT(kind() == REG_DISP || kind() == SCALE);
         return disp_;
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #include "jit/shared/Assembler-x86-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // Return operand from a JS -> JS call.
 static MOZ_CONSTEXPR_VAR ValueOperand JSReturnOperand = ValueOperand(JSReturnReg);
 
 class Assembler : public AssemblerX86Shared
 {
     // x64 jumps may need extra bits of relocation, because a jump may extend
     // beyond the signed 32-bit range. To account for this we add an extended
@@ -770,12 +770,12 @@ GetFloatArgReg(uint32_t intArg, uint32_t
     uint32_t arg = floatArg;
 #endif
     if (floatArg >= NumFloatArgRegs)
         return false;
     *out = FloatArgRegs[arg];
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_Assembler_x64_h */
--- a/js/src/jit/x64/Bailouts-x64.cpp
+++ b/js/src/jit/x64/Bailouts-x64.cpp
@@ -6,24 +6,24 @@
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/Bailouts.h"
 #include "jit/IonCompartment.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 #if defined(_WIN32)
 # pragma pack(push, 1)
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BailoutStack
 {
     double    fpregs_[FloatRegisters::Total];
     uintptr_t regs_[Registers::Total];
     uintptr_t frameSize_;
     uintptr_t snapshotOffset_;
 
@@ -37,17 +37,17 @@ class BailoutStack
     uint32_t frameSize() const {
         return frameSize_;
     }
     uint8_t *parentStackPointer() {
         return (uint8_t *)this + sizeof(BailoutStack);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #if defined(_WIN32)
 # pragma pack(pop)
 #endif
 
 IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
                                        BailoutStack *bailout)
--- a/js/src/jit/x64/BaselineCompiler-x64.cpp
+++ b/js/src/jit/x64/BaselineCompiler-x64.cpp
@@ -2,14 +2,14 @@
  * 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/x64/BaselineCompiler-x64.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BaselineCompilerX64::BaselineCompilerX64(JSContext *cx, HandleScript script)
   : BaselineCompilerX86Shared(cx, script)
 {
 }
--- a/js/src/jit/x64/BaselineCompiler-x64.h
+++ b/js/src/jit/x64/BaselineCompiler-x64.h
@@ -5,22 +5,22 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_BaselineCompiler_x64_h
 #define jit_x64_BaselineCompiler_x64_h
 
 #include "jit/shared/BaselineCompiler-x86-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BaselineCompilerX64 : public BaselineCompilerX86Shared
 {
   protected:
     BaselineCompilerX64(JSContext *cx, HandleScript script);
 };
 
 typedef BaselineCompilerX64 BaselineCompilerSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_BaselineCompiler_x64_h */
--- a/js/src/jit/x64/BaselineHelpers-x64.h
+++ b/js/src/jit/x64/BaselineHelpers-x64.h
@@ -9,17 +9,17 @@
 
 #ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+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
 EmitRestoreTailCallReg(MacroAssembler &masm)
 {
     masm.pop(BaselineTailCallReg);
@@ -267,14 +267,14 @@ EmitStubGuardFailure(MacroAssembler &mas
     // Load next stub into BaselineStubReg
     masm.movq(Operand(BaselineStubReg, ICStub::offsetOfNext()), BaselineStubReg);
 
     // Return address is already loaded, just jump to the next stubcode.
     masm.jmp(Operand(BaselineStubReg, ICStub::offsetOfStubCode()));
 }
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_x64_BaselineHelpers_x64_h */
--- a/js/src/jit/x64/BaselineIC-x64.cpp
+++ b/js/src/jit/x64/BaselineIC-x64.cpp
@@ -6,20 +6,20 @@
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/IonLinker.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // ICCompare_Int32
 
 bool
 ICCompare_Int32::Compiler::generateStubCode(MacroAssembler &masm)
 {
     // Guard that R0 is an integer and R1 is an integer.
     Label failure;
@@ -236,10 +236,10 @@ ICUnaryArith_Int32::Compiler::generateSt
 
     EmitReturnFromIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/x64/BaselineRegisters-x64.h
+++ b/js/src/jit/x64/BaselineRegisters-x64.h
@@ -7,17 +7,17 @@
 #ifndef jit_x64_BaselineRegisters_x64_h
 #define jit_x64_BaselineRegisters_x64_h
 
 #ifdef JS_ION
 
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg    = rbp;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg    = rsp;
 
 static MOZ_CONSTEXPR_VAR ValueOperand R0(rcx);
 static MOZ_CONSTEXPR_VAR ValueOperand R1(rbx);
 static MOZ_CONSTEXPR_VAR ValueOperand R2(rax);
 
@@ -28,14 +28,14 @@ static MOZ_CONSTEXPR_VAR Register Baseli
 
 static MOZ_CONSTEXPR_VAR Register ExtractTemp0        = r14;
 static MOZ_CONSTEXPR_VAR Register ExtractTemp1        = r15;
 
 // FloatReg0 must be equal to ReturnFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = xmm0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = xmm1;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_x64_BaselineRegisters_x64_h */
--- a/js/src/jit/x64/CodeGenerator-x64.cpp
+++ b/js/src/jit/x64/CodeGenerator-x64.cpp
@@ -12,17 +12,17 @@
 #include "jit/MIRGraph.h"
 #include "vm/Shape.h"
 
 #include "jsscriptinlines.h"
 
 #include "jit/shared/CodeGenerator-shared-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 CodeGeneratorX64::CodeGeneratorX64(MIRGenerator *gen, LIRGraph *graph, MacroAssembler *masm)
   : CodeGeneratorX86Shared(gen, graph, masm)
 {
 }
 
 ValueOperand
 CodeGeneratorX64::ToValue(LInstruction *ins, size_t pos)
--- a/js/src/jit/x64/CodeGenerator-x64.h
+++ b/js/src/jit/x64/CodeGenerator-x64.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_x64_CodeGenerator_x64_h
 #define jit_x64_CodeGenerator_x64_h
 
 #include "jit/shared/CodeGenerator-x86-shared.h"
 #include "jit/x64/Assembler-x64.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class CodeGeneratorX64 : public CodeGeneratorX86Shared
 {
     CodeGeneratorX64 *thisFromCtor() {
         return this;
     }
 
   protected:
@@ -61,12 +61,12 @@ class CodeGeneratorX64 : public CodeGene
     bool visitAsmJSLoadFuncPtr(LAsmJSLoadFuncPtr *ins);
     bool visitAsmJSLoadFFIFunc(LAsmJSLoadFFIFunc *ins);
 
     void postAsmJSCall(LAsmJSCall *lir) {}
 };
 
 typedef CodeGeneratorX64 CodeGeneratorSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_CodeGenerator_x64_h */
--- a/js/src/jit/x64/LIR-x64.h
+++ b/js/src/jit/x64/LIR-x64.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_x64_LIR_x64_h
 #define jit_x64_LIR_x64_h
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // Given a typed input, returns an untyped box.
 class LBox : public LInstructionHelper<1, 1, 0>
 {
     MIRType type_;
 
   public:
     LIR_HEADER(Box)
@@ -88,12 +88,12 @@ class LAsmJSLoadFuncPtr : public LInstru
     const LAllocation *index() {
         return getOperand(0);
     }
     const LDefinition *temp() {
         return getTemp(0);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_LIR_x64_h */
--- a/js/src/jit/x64/Lowering-x64.cpp
+++ b/js/src/jit/x64/Lowering-x64.cpp
@@ -7,17 +7,17 @@
 #include "jit/x64/Lowering-x64.h"
 
 #include "jit/MIR.h"
 #include "jit/x64/Assembler-x64.h"
 
 #include "jit/shared/Lowering-shared-inl.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 bool
 LIRGeneratorX64::useBox(LInstruction *lir, size_t n, MDefinition *mir,
                         LUse::Policy policy, bool useAtStart)
 {
     JS_ASSERT(mir->type() == MIRType_Value);
 
     if (!ensureDefined(mir))
--- a/js/src/jit/x64/Lowering-x64.h
+++ b/js/src/jit/x64/Lowering-x64.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_Lowering_x64_h
 #define jit_x64_Lowering_x64_h
 
 #include "jit/shared/Lowering-x86-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class LIRGeneratorX64 : public LIRGeneratorX86Shared
 {
   public:
     LIRGeneratorX64(MIRGenerator *gen, MIRGraph &graph, LIRGraph &lirGraph)
       : LIRGeneratorX86Shared(gen, graph, lirGraph)
     { }
 
@@ -42,12 +42,12 @@ class LIRGeneratorX64 : public LIRGenera
     bool visitAsmJSUnsignedToDouble(MAsmJSUnsignedToDouble *ins);
     bool visitAsmJSStoreHeap(MAsmJSStoreHeap *ins);
     bool visitAsmJSLoadFuncPtr(MAsmJSLoadFuncPtr *ins);
     bool visitStoreTypedArrayElementStatic(MStoreTypedArrayElementStatic *ins);
 };
 
 typedef LIRGeneratorX64 LIRGeneratorSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_Lowering_x64_h */
--- a/js/src/jit/x64/MacroAssembler-x64.cpp
+++ b/js/src/jit/x64/MacroAssembler-x64.cpp
@@ -8,17 +8,17 @@
 
 #include "mozilla/Casting.h"
 
 #include "jit/BaselineFrame.h"
 #include "jit/IonFrames.h"
 #include "jit/MoveEmitter.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 void
 MacroAssemblerX64::loadConstantDouble(double d, const FloatRegister &dest)
 {
     if (maybeInlineDouble(d, dest))
         return;
 
     if (!doubleMap_.initialized()) {
--- a/js/src/jit/x64/MacroAssembler-x64.h
+++ b/js/src/jit/x64/MacroAssembler-x64.h
@@ -9,17 +9,17 @@
 
 #include "jsnum.h"
 
 #include "jit/IonFrames.h"
 #include "jit/MoveResolver.h"
 #include "jit/shared/MacroAssembler-x86-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 struct ImmShiftedTag : public ImmWord
 {
     ImmShiftedTag(JSValueShiftedTag shtag)
       : ImmWord((uintptr_t)shtag)
     { }
 
     ImmShiftedTag(JSValueType type)
@@ -1126,12 +1126,12 @@ class MacroAssemblerX64 : public MacroAs
         load32(Source, ScratchReg);
         storeValue(JSVAL_TYPE_INT32, ScratchReg, Dest);
     }
 
 };
 
 typedef MacroAssemblerX64 MacroAssemblerSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x64_MacroAssembler_x64_h */
--- a/js/src/jit/x64/Trampoline-x64.cpp
+++ b/js/src/jit/x64/Trampoline-x64.cpp
@@ -12,17 +12,17 @@
 #include "jit/IonCompartment.h"
 #include "jit/IonFrames.h"
 #include "jit/IonLinker.h"
 #include "jit/IonSpewer.h"
 #include "jit/VMFunctions.h"
 #include "jit/x64/BaselineHelpers-x64.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 // All registers to save and restore. This includes the stack pointer, since we
 // use the ability to reference register values on the stack by index.
 static const RegisterSet AllRegs =
   RegisterSet(GeneralRegisterSet(Registers::AllMask),
               FloatRegisterSet(FloatRegisters::AllMask));
 
 /* This method generates a trampoline on x64 for a c++ function with
@@ -191,17 +191,17 @@ IonRuntime::generateEnterJIT(JSContext *
 
         masm.push(framePtr);
         masm.push(reg_code);
 
         masm.setupUnalignedABICall(3, scratch);
         masm.passABIArg(framePtr); // BaselineFrame
         masm.passABIArg(OsrFrameReg); // StackFrame
         masm.passABIArg(numStackValues);
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, ion::InitBaselineFrameForOsr));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, jit::InitBaselineFrameForOsr));
 
         masm.pop(reg_code);
         masm.pop(framePtr);
 
         JS_ASSERT(reg_code != ReturnReg);
 
         Label error;
         masm.addPtr(Imm32(IonExitFrameLayout::SizeWithFooter()), rsp);
@@ -284,17 +284,17 @@ IonRuntime::generateInvalidator(JSContex
 
     // See explanatory comment in x86's IonRuntime::generateInvalidator.
 
     masm.addq(Imm32(sizeof(uintptr_t)), rsp);
 
     // Push registers such that we can access them from [base + code].
     masm.PushRegsInMask(AllRegs);
 
-    masm.movq(rsp, rax); // Argument to ion::InvalidationBailout.
+    masm.movq(rsp, rax); // Argument to jit::InvalidationBailout.
 
     // Make space for InvalidationBailout's frameSize outparam.
     masm.reserveStack(sizeof(size_t));
     masm.movq(rsp, rbx);
 
     // Make space for InvalidationBailout's bailoutInfo outparam.
     masm.reserveStack(sizeof(void *));
     masm.movq(rsp, r9);
--- a/js/src/jit/x86/Architecture-x86.h
+++ b/js/src/jit/x86/Architecture-x86.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_Architecture_x86_h
 #define jit_x86_Architecture_x86_h
 
 #include "assembler/assembler/MacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 static const ptrdiff_t STACK_SLOT_SIZE       = 4;
 static const uint32_t DOUBLE_STACK_ALIGNMENT   = 2;
 
 // In bytes: slots needed for potential memory->memory move spills.
 //   +8 for cycles
 //   +4 for gpr spills
 //   +8 for double spills
 static const uint32_t ION_FRAME_SLACK_SIZE    = 20;
@@ -125,12 +125,12 @@ class FloatRegisters {
     static const uint32_t WrapperMask = VolatileMask;
 
     static const uint32_t NonAllocatableMask =
         (1 << JSC::X86Registers::xmm7);
 
     static const uint32_t AllocatableMask = AllMask & ~NonAllocatableMask;
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x86_Architecture_x86_h */
--- a/js/src/jit/x86/Assembler-x86.cpp
+++ b/js/src/jit/x86/Assembler-x86.cpp
@@ -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/. */
 
 #include "jit/x86/Assembler-x86.h"
 
 #include "gc/Marking.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 ABIArgGenerator::ABIArgGenerator()
   : stackOffset_(0),
     current_()
 {}
 
 ABIArg
 ABIArgGenerator::next(MIRType type)
--- a/js/src/jit/x86/Assembler-x86.h
+++ b/js/src/jit/x86/Assembler-x86.h
@@ -10,17 +10,17 @@
 #include "mozilla/Util.h"
 
 #include "assembler/assembler/X86Assembler.h"
 #include "jit/CompactBuffer.h"
 #include "jit/IonCode.h"
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register eax = { JSC::X86Registers::eax };
 static MOZ_CONSTEXPR_VAR Register ecx = { JSC::X86Registers::ecx };
 static MOZ_CONSTEXPR_VAR Register edx = { JSC::X86Registers::edx };
 static MOZ_CONSTEXPR_VAR Register ebx = { JSC::X86Registers::ebx };
 static MOZ_CONSTEXPR_VAR Register esp = { JSC::X86Registers::esp };
 static MOZ_CONSTEXPR_VAR Register ebp = { JSC::X86Registers::ebp };
 static MOZ_CONSTEXPR_VAR Register esi = { JSC::X86Registers::esi };
@@ -205,23 +205,23 @@ class Operand
         return disp_;
     }
     void *address() const {
         JS_ASSERT(kind() == ADDRESS);
         return reinterpret_cast<void *>(base_);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #include "jit/shared/Assembler-x86-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static inline void
 PatchJump(CodeLocationJump jump, CodeLocationLabel label)
 {
 #ifdef DEBUG
     // Assert that we're overwriting a jump instruction, either:
     //   0F 80+cc <imm32>, or
     //   E9 <imm32>
@@ -545,12 +545,12 @@ static inline bool
 GetTempRegForIntArg(uint32_t usedIntArgs, uint32_t usedFloatArgs, Register *out)
 {
     if (usedIntArgs >= NumCallTempNonArgRegs)
         return false;
     *out = CallTempNonArgRegs[usedIntArgs];
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x86_Assembler_x86_h */
--- a/js/src/jit/x86/Bailouts-x86.cpp
+++ b/js/src/jit/x86/Bailouts-x86.cpp
@@ -6,24 +6,24 @@
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/Bailouts.h"
 #include "jit/IonCompartment.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 #if defined(_WIN32)
 # pragma pack(push, 1)
 #endif
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BailoutStack
 {
     uintptr_t frameClassId_;
     double    fpregs_[FloatRegisters::Total];
     uintptr_t regs_[Registers::Total];
     union {
         uintptr_t frameSize_;
@@ -53,17 +53,17 @@ class BailoutStack
     }
     uint8_t *parentStackPointer() const {
         if (frameClass() == FrameSizeClass::None())
             return (uint8_t *)this + sizeof(BailoutStack);
         return (uint8_t *)this + offsetof(BailoutStack, snapshotOffset_);
     }
 };
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #if defined(_WIN32)
 # pragma pack(pop)
 #endif
 
 IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
                                        BailoutStack *bailout)
--- a/js/src/jit/x86/BaselineCompiler-x86.cpp
+++ b/js/src/jit/x86/BaselineCompiler-x86.cpp
@@ -2,14 +2,14 @@
  * 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/x86/BaselineCompiler-x86.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 BaselineCompilerX86::BaselineCompilerX86(JSContext *cx, HandleScript script)
   : BaselineCompilerX86Shared(cx, script)
 {
 }
--- a/js/src/jit/x86/BaselineCompiler-x86.h
+++ b/js/src/jit/x86/BaselineCompiler-x86.h
@@ -5,22 +5,22 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_BaselineCompiler_x86_h
 #define jit_x86_BaselineCompiler_x86_h
 
 #include "jit/shared/BaselineCompiler-x86-shared.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 class BaselineCompilerX86 : public BaselineCompilerX86Shared
 {
   protected:
     BaselineCompilerX86(JSContext *cx, HandleScript script);
 };
 
 typedef BaselineCompilerX86 BaselineCompilerSpecific;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif /* jit_x86_BaselineCompiler_x86_h */
--- a/js/src/jit/x86/BaselineHelpers-x86.h
+++ b/js/src/jit/x86/BaselineHelpers-x86.h
@@ -9,17 +9,17 @@
 
 #ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+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
 EmitRestoreTailCallReg(MacroAssembler &masm)
 {
     masm.pop(BaselineTailCallReg);
@@ -273,14 +273,14 @@ EmitStubGuardFailure(MacroAssembler &mas
     // Load next stub into BaselineStubReg
     masm.movl(Operand(BaselineStubReg, (int32_t) ICStub::offsetOfNext()), BaselineStubReg);
 
     // Return address is already loaded, just jump to the next stubcode.
     masm.jmp(Operand(BaselineStubReg, (int32_t) ICStub::offsetOfStubCode()));
 }
 
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
 #endif /* jit_x86_BaselineHelpers_x86_h */
--- a/js/src/jit/x86/BaselineIC-x86.cpp
+++ b/js/src/jit/x86/BaselineIC-x86.cpp
@@ -6,20 +6,20 @@
 
 #include "jit/BaselineCompiler.h"
 #include "jit/BaselineHelpers.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/IonLinker.h"
 
 using namespace js;
-using namespace js::ion;
+using namespace js::jit;
 
 namespace js {
-namespace ion {
+namespace jit {
 
 // ICCompare_Int32
 
 bool
 ICCompare_Int32::Compiler::generateStubCode(MacroAssembler &masm)
 {
     // Guard that R0 is an integer and R1 is an integer.
     Label failure;
@@ -250,10 +250,10 @@ ICUnaryArith_Int32::Compiler::generateSt
 
     EmitReturnFromIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
-} // namespace ion
+} // namespace jit
 } // namespace js
--- a/js/src/jit/x86/BaselineRegisters-x86.h
+++ b/js/src/jit/x86/BaselineRegisters-x86.h
@@ -7,17 +7,17 @@
 #ifndef jit_x86_BaselineRegisters_x86_h
 #define jit_x86_BaselineRegisters_x86_h
 
 #ifdef JS_ION
 
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
-namespace ion {
+namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = ebp;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = esp;
 
 // ValueOperands R0, R1, and R2
 static MOZ_CONSTEXPR_VAR ValueOperand R0(ecx, edx);
 static MOZ_CONSTEXPR_VAR ValueOperand R1(eax, ebx);
 static MOZ_CONSTEXPR_VAR ValueOperand R2(esi, edi);
@@ -29,14 +29,14 @@ static MOZ_CONSTEXPR_VAR Register Baseli
 
 static MOZ_CONSTEXPR_VAR Register ExtractTemp0        = InvalidReg;
 static MOZ_CONSTEXPR_VAR Register ExtractTemp1        = InvalidReg;
 
 // FloatReg0 must be equal to ReturnFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = xmm0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = xmm1;
 
-} // namespace ion
+} // namespace jit
 } // namespace js
 
 #endif // JS_ION
 
<