Bug 1042833 - Remove JS_ION #ifdef, r=jandem.
authorBrian Hackett <bhackett1024@gmail.com>
Tue, 29 Jul 2014 12:51:40 -0800
changeset 196721 c2eb3dd6223311080954565586434d97f7967f3e
parent 196720 b05b6fe7524ed20c658b5a416c938537bbec62ef
child 196722 d4552a868ba9abed5e2ae1858f7f0c6182cbf3ac
push id27223
push usercbook@mozilla.com
push dateWed, 30 Jul 2014 11:56:43 +0000
treeherderautoland@08c23f12a43e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem
bugs1042833
milestone34.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1042833 - Remove JS_ION #ifdef, r=jandem.
js/src/assembler/assembler/AssemblerBuffer.h
js/src/builtin/TestingFunctions.cpp
js/src/configure.in
js/src/frontend/Parser.cpp
js/src/gc/ForkJoinNursery.cpp
js/src/gc/ForkJoinNursery.h
js/src/gc/Marking.cpp
js/src/gc/Marking.h
js/src/gc/Nursery.cpp
js/src/gc/RootMarking.cpp
js/src/gc/StoreBuffer.cpp
js/src/gc/Zone.cpp
js/src/irregexp/NativeRegExpMacroAssembler.h
js/src/irregexp/RegExpEngine.cpp
js/src/irregexp/RegExpEngine.h
js/src/jit/AsmJS.h
js/src/jit/AsmJSLink.h
js/src/jit/AsmJSModule.h
js/src/jit/BaselineCompiler.h
js/src/jit/BaselineDebugModeOSR.h
js/src/jit/BaselineFrame-inl.h
js/src/jit/BaselineFrame.h
js/src/jit/BaselineFrameInfo.h
js/src/jit/BaselineHelpers.h
js/src/jit/BaselineIC.h
js/src/jit/BaselineInspector.h
js/src/jit/BaselineJIT.h
js/src/jit/BaselineRegisters.h
js/src/jit/CompileWrappers.h
js/src/jit/CompilerRoot.h
js/src/jit/ExecutionMode-inl.h
js/src/jit/Ion.h
js/src/jit/IonAnalysis.h
js/src/jit/IonBuilder.h
js/src/jit/IonFrames-inl.h
js/src/jit/IonFrames.h
js/src/jit/IonMacroAssembler.h
js/src/jit/IonOptimizationLevels.h
js/src/jit/IonTypes.h
js/src/jit/JitCompartment.h
js/src/jit/JitFrameIterator-inl.h
js/src/jit/JitFrameIterator.h
js/src/jit/JitOptions.h
js/src/jit/RematerializedFrame.h
js/src/jit/ScalarReplacement.h
js/src/jit/arm/BaselineHelpers-arm.h
js/src/jit/arm/BaselineRegisters-arm.h
js/src/jit/mips/BaselineHelpers-mips.h
js/src/jit/mips/BaselineRegisters-mips.h
js/src/jit/x64/BaselineHelpers-x64.h
js/src/jit/x64/BaselineRegisters-x64.h
js/src/jit/x86/BaselineHelpers-x86.h
js/src/jit/x86/BaselineRegisters-x86.h
js/src/jsapi.cpp
js/src/jsarray.cpp
js/src/jscntxt.cpp
js/src/jscntxtinlines.h
js/src/jscompartment.cpp
js/src/jscompartment.h
js/src/jsfun.cpp
js/src/jsgc.cpp
js/src/jsgc.h
js/src/jsinfer.cpp
js/src/jsinferinlines.h
js/src/jsobj.cpp
js/src/jsopcode.cpp
js/src/jsopcode.h
js/src/jsscript.cpp
js/src/jsscriptinlines.h
js/src/shell/js.cpp
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArgumentsObject.h
js/src/vm/ArrayBufferObject.cpp
js/src/vm/Debugger.cpp
js/src/vm/ForkJoin.cpp
js/src/vm/ForkJoin.h
js/src/vm/HelperThreads.cpp
js/src/vm/HelperThreads.h
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/src/vm/MemoryMetrics.cpp
js/src/vm/OldDebugAPI.cpp
js/src/vm/RegExpObject.cpp
js/src/vm/RegExpObject.h
js/src/vm/Runtime.cpp
js/src/vm/Runtime.h
js/src/vm/SPSProfiler.cpp
js/src/vm/Stack-inl.h
js/src/vm/Stack.cpp
js/src/vm/Stack.h
--- a/js/src/assembler/assembler/AssemblerBuffer.h
+++ b/js/src/assembler/assembler/AssemblerBuffer.h
@@ -285,60 +285,50 @@ namespace JSC {
             printer = sp;
         }
 
         void spew(const char *fmt, ...)
 #ifdef __GNUC__
             __attribute__ ((format (printf, 2, 3)))
 #endif
         {
-            if (printer
-#ifdef JS_ION
-                || js::jit::IonSpewEnabled(js::jit::IonSpew_Codegen)
-#endif
-                )
-            {
+            if (printer || js::jit::IonSpewEnabled(js::jit::IonSpew_Codegen)) {
                 // 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;
                 va_start(va, fmt);
                 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::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::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::jit::IonSpew(js::jit::IonSpew_Codegen, "%s", buf);
             }
-#endif
         }
     };
 
 } // namespace JSC
 
 #endif // ENABLE(ASSEMBLER)
 
 #endif /* assembler_assembler_AssemblerBuffer_h */
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -1102,17 +1102,17 @@ DisableSPSProfiling(JSContext *cx, unsig
     args.rval().setUndefined();
     return true;
 }
 
 static bool
 EnableOsiPointRegisterChecks(JSContext *, unsigned argc, jsval *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
-#if defined(JS_ION) && defined(CHECK_OSIPOINT_REGISTERS)
+#ifdef CHECK_OSIPOINT_REGISTERS
     jit::js_JitOptions.checkOsiPointRegisters = true;
 #endif
     args.rval().setUndefined();
     return true;
 }
 
 static bool
 DisplayName(JSContext *cx, unsigned argc, jsval *vp)
@@ -1320,19 +1320,17 @@ GetJitCompilerOptions(JSContext *cx, uns
 
     return true;
 }
 
 static bool
 SetIonCheckGraphCoherency(JSContext *cx, unsigned argc, jsval *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
-#ifdef JS_ION
     jit::js_JitOptions.checkGraphConsistency = ToBoolean(args.get(0));
-#endif
     args.rval().setUndefined();
     return true;
 }
 
 class CloneBufferObject : public JSObject {
     static const JSPropertySpec props_[2];
     static const size_t DATA_SLOT   = 0;
     static const size_t LENGTH_SLOT = 1;
--- a/js/src/configure.in
+++ b/js/src/configure.in
@@ -2019,18 +2019,16 @@ esac
 MOZ_ARG_DISABLE_BOOL(ion,
 [  --disable-ion      Disable use of the IonMonkey JIT],
   ENABLE_ION= )
 
 AC_SUBST(ENABLE_METHODJIT_SPEW)
 
 AC_SUBST(ENABLE_ION)
 
-AC_DEFINE(JS_ION)
-
 if test -n "$COMPILE_ENVIRONMENT"; then
     MOZ_COMPILER_OPTS
 fi
 
 if test -z "$SKIP_COMPILER_CHECKS"; then
 dnl Checks for typedefs, structures, and compiler characteristics.
 dnl ========================================================
 AC_HEADER_STDC
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -2539,30 +2539,28 @@ Parser<FullParseHandler>::asmJS(Node lis
 
     // If there is no ScriptSource, then we are doing a non-compiling parse and
     // so we shouldn't (and can't, without a ScriptSource) compile.
     if (ss == nullptr)
         return true;
 
     pc->sc->asFunctionBox()->useAsm = true;
 
-#ifdef JS_ION
     // Attempt to validate and compile this asm.js module. On success, the
     // tokenStream has been advanced to the closing }. On failure, the
     // tokenStream is in an indeterminate state and we must reparse the
     // function from the beginning. Reparsing is triggered by marking that a
     // new directive has been encountered and returning 'false'.
     bool validated;
     if (!CompileAsmJS(context, *this, list, &validated))
         return false;
     if (!validated) {
         pc->newDirectives->setAsmJS();
         return false;
     }
-#endif
 
     return true;
 }
 
 /*
  * Recognize Directive Prologue members and directives. Assuming |pn| is a
  * candidate for membership in a directive prologue, recognize directives and
  * set |pc|'s flags accordingly. If |pn| is indeed part of a prologue, set its
--- a/js/src/gc/ForkJoinNursery.cpp
+++ b/js/src/gc/ForkJoinNursery.cpp
@@ -250,19 +250,17 @@ ForkJoinNursery::pjsCollection(int op)
         if (!initNewspace())
             CrashAtUnhandlableOOM("Cannot expand PJS nursery during GC");
         // newspace must be at least as large as fromSpace
         numActiveChunks_ = currentNumActiveChunks_;
     }
     ForkJoinNurseryCollectionTracer trc(rt, this);
     forwardFromRoots(&trc);
     collectToFixedPoint(&trc);
-#ifdef JS_ION
     jit::UpdateJitActivationsForMinorGC<ForkJoinNursery>(TlsPerThreadData.get(), &trc);
-#endif
     freeFromspace();
 
     size_t live = movedSize_;
     computeNurserySizeAfterGC(live, &msg);
 
     sweepHugeSlots();
     JS_ASSERT(hugeSlots[hugeSlotsFrom].empty());
     JS_ASSERT_IF(isEvacuating_, hugeSlots[hugeSlotsNew].empty());
--- a/js/src/gc/ForkJoinNursery.h
+++ b/js/src/gc/ForkJoinNursery.h
@@ -8,19 +8,16 @@
 #ifndef gc_ForkJoinNursery_h
 #define gc_ForkJoinNursery_h
 
 #ifdef JSGC_FJGENERATIONAL
 
 #ifndef JSGC_GENERATIONAL
 #error "JSGC_GENERATIONAL is required for the ForkJoinNursery"
 #endif
-#ifndef JS_ION
-#error "JS_ION is required for the ForkJoinNursery"
-#endif
 
 #include "jsalloc.h"
 #include "jspubtd.h"
 
 #include "gc/Heap.h"
 #include "gc/Memory.h"
 #include "gc/Nursery.h"
 
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -1413,19 +1413,17 @@ gc::MarkChildren(JSTracer *trc, types::T
 
     if (type->interpretedFunction)
         MarkObject(trc, &type->interpretedFunction, "type_function");
 }
 
 static void
 gc::MarkChildren(JSTracer *trc, jit::JitCode *code)
 {
-#ifdef JS_ION
     code->trace(trc);
-#endif
 }
 
 template<typename T>
 static void
 PushArenaTyped(GCMarker *gcmarker, ArenaHeader *aheader)
 {
     for (ArenaCellIterUnderGC i(aheader); !i.done(); i.next())
         PushMarkStack(gcmarker, i.get<T>());
--- a/js/src/gc/Marking.h
+++ b/js/src/gc/Marking.h
@@ -349,35 +349,31 @@ IsAboutToBeFinalized(BarrieredBase<JSObj
 }
 
 inline bool
 IsAboutToBeFinalized(BarrieredBase<JSScript*> *scriptp)
 {
     return IsScriptAboutToBeFinalized(scriptp);
 }
 
-#ifdef JS_ION
-/* Nonsense to get WeakCache to work with new Marking semantics. */
-
 inline bool
 IsAboutToBeFinalized(const js::jit::VMFunction **vmfunc)
 {
     /*
      * Preserves entries in the WeakCache<VMFunction, JitCode>
      * iff the JitCode has been marked.
      */
     return false;
 }
 
 inline bool
 IsAboutToBeFinalized(ReadBarrieredJitCode code)
 {
     return IsJitCodeAboutToBeFinalized(code.unsafeGet());
 }
-#endif
 
 inline Cell *
 ToMarkable(const Value &v)
 {
     if (v.isMarkable())
         return (Cell *)v.toGCThing();
     return nullptr;
 }
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -4,28 +4,27 @@
  * 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/. */
 
 #ifdef JSGC_GENERATIONAL
 
 #include "gc/Nursery-inl.h"
 
+#include "mozilla/IntegerPrintfMacros.h"
+
 #include "jscompartment.h"
 #include "jsgc.h"
 #include "jsinfer.h"
 #include "jsutil.h"
 #include "prmjtime.h"
 
 #include "gc/GCInternals.h"
 #include "gc/Memory.h"
-#ifdef JS_ION
 #include "jit/IonFrames.h"
-#endif
-#include "mozilla/IntegerPrintfMacros.h"
 #include "vm/ArrayObject.h"
 #include "vm/Debugger.h"
 #if defined(DEBUG)
 #include "vm/ScopeObject.h"
 #endif
 #include "vm/TypedArrayObject.h"
 
 #include "jsgcinlines.h"
@@ -846,19 +845,17 @@ js::Nursery::collect(JSRuntime *rt, JS::
     for (CompartmentsIter c(rt, SkipAtoms); !c.done(); c.next()) {
         if (!c->gcLiveArrayBuffers.empty())
             ArrayBufferObject::sweep(c);
     }
     TIME_END(sweepArrayBufferViewList);
 
     // Update any slot or element pointers whose destination has been tenured.
     TIME_START(updateJitActivations);
-#ifdef JS_ION
     js::jit::UpdateJitActivationsForMinorGC<Nursery>(&rt->mainThread, &trc);
-#endif
     TIME_END(updateJitActivations);
 
     // Resize the nursery.
     TIME_START(resize);
     double promotionRate = trc.tenuredSize / double(allocationEnd() - start());
     if (promotionRate > 0.05)
         growAllocableSpace();
     else if (promotionRate < 0.01)
--- a/js/src/gc/RootMarking.cpp
+++ b/js/src/gc/RootMarking.cpp
@@ -17,19 +17,17 @@
 #include "jstypes.h"
 #include "jswatchpoint.h"
 
 #include "builtin/MapObject.h"
 #include "frontend/BytecodeCompiler.h"
 #include "gc/ForkJoinNursery.h"
 #include "gc/GCInternals.h"
 #include "gc/Marking.h"
-#ifdef JS_ION
-# include "jit/IonMacroAssembler.h"
-#endif
+#include "jit/IonMacroAssembler.h"
 #include "js/HashTable.h"
 #include "vm/Debugger.h"
 #include "vm/PropDesc.h"
 
 #include "jsgcinlines.h"
 #include "jsobjinlines.h"
 
 using namespace js;
@@ -300,17 +298,17 @@ MarkRangeConservatively(JSTracer *trc, c
         MarkWordConservatively(trc, *i);
 }
 
 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) && !defined(JS_ARM_SIMULATOR) && !defined(JS_MIPS_SIMULATOR)
+#if JS_STACK_GROWTH_DIRECTION < 0 && !defined(JS_ARM_SIMULATOR) && !defined(JS_MIPS_SIMULATOR)
     // 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.
     //
     // If the ARM or MIPS simulator is enabled, JIT activations are not on
     // the native stack but on the simulator stack, so we don't have to skip
     // JIT regions in this case.
     for (jit::JitActivationIterator iter(rt); !iter.done(); ++iter) {
@@ -533,26 +531,22 @@ AutoGCRooter::trace(JSTracer *trc)
 
       case HASHABLEVALUE: {
         AutoHashableValueRooter *rooter = static_cast<AutoHashableValueRooter *>(this);
         rooter->trace(trc);
         return;
       }
 
       case IONMASM: {
-#ifdef JS_ION
         static_cast<js::jit::MacroAssembler::AutoRooter *>(this)->masm()->trace(trc);
-#endif
         return;
       }
 
       case IONALLOC: {
-#ifdef JS_ION
         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
          * RemapAllWrappersForObject; see comment there.
@@ -765,19 +759,17 @@ js::gc::GCRuntime::markRuntime(JSTracer 
             MarkScriptRoot(trc, &vec[i].script, "scriptAndCountsVector");
     }
 
     if (!rt->isBeingDestroyed() && !trc->runtime()->isHeapMinorCollecting()) {
         if (!IS_GC_MARKING_TRACER(trc) || rt->atomsCompartment()->zone()->isCollecting()) {
             MarkPermanentAtoms(trc);
             MarkAtoms(trc);
             MarkWellKnownSymbols(trc);
-#ifdef JS_ION
             jit::JitRuntime::Mark(trc);
-#endif
         }
     }
 
     for (ContextIter acx(rt); !acx.done(); acx.next())
         acx->mark(trc);
 
     for (ZonesIter zone(rt, SkipAtoms); !zone.done(); zone.next()) {
         if (IS_GC_MARKING_TRACER(trc) && !zone->isCollecting())
@@ -811,19 +803,17 @@ js::gc::GCRuntime::markRuntime(JSTracer 
 
         /* Mark debug scopes, if present */
         if (c->debugScopes)
             c->debugScopes->mark(trc);
     }
 
     MarkInterpreterActivations(&rt->mainThread, trc);
 
-#ifdef JS_ION
     jit::MarkJitActivations(&rt->mainThread, trc);
-#endif
 
     if (!isHeapMinorCollecting()) {
         /*
          * All JSCompartment::mark does is mark the globals for compartments
          * which have been entered. Globals aren't nursery allocated so there's
          * no need to do this for minor GCs.
          */
         for (CompartmentsIter c(rt, SkipAtoms); !c.done(); c.next())
--- a/js/src/gc/StoreBuffer.cpp
+++ b/js/src/gc/StoreBuffer.cpp
@@ -57,22 +57,18 @@ StoreBuffer::WholeCellEdges::mark(JSTrac
     JSGCTraceKind kind = GetGCThingTraceKind(edge);
     if (kind <= JSTRACE_OBJECT) {
         JSObject *object = static_cast<JSObject *>(edge);
         if (object->is<ArgumentsObject>())
             ArgumentsObject::trace(trc, object);
         MarkChildren(trc, object);
         return;
     }
-#ifdef JS_ION
     JS_ASSERT(kind == JSTRACE_JITCODE);
     static_cast<jit::JitCode *>(edge)->trace(trc);
-#else
-    MOZ_CRASH("Only objects can be in the wholeCellBuffer if IonMonkey is disabled.");
-#endif
 }
 
 void
 StoreBuffer::CellPtrEdge::mark(JSTracer *trc)
 {
     if (!*edge)
         return;
 
--- a/js/src/gc/Zone.cpp
+++ b/js/src/gc/Zone.cpp
@@ -3,21 +3,19 @@
  * 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/Zone.h"
 
 #include "jsgc.h"
 
-#ifdef JS_ION
 #include "jit/BaselineJIT.h"
 #include "jit/Ion.h"
 #include "jit/JitCompartment.h"
-#endif
 #include "vm/Debugger.h"
 #include "vm/Runtime.h"
 
 #include "jsgcinlines.h"
 
 using namespace js;
 using namespace js::gc;
 
@@ -52,35 +50,31 @@ JS::Zone::Zone(JSRuntime *rt)
 }
 
 Zone::~Zone()
 {
     JSRuntime *rt = runtimeFromMainThread();
     if (this == rt->gc.systemZone)
         rt->gc.systemZone = nullptr;
 
-#ifdef JS_ION
     js_delete(jitZone_);
-#endif
 }
 
 bool Zone::init()
 {
     return gcZoneGroupEdges.init();
 }
 
 void
 Zone::setNeedsBarrier(bool needs, ShouldUpdateJit updateJit)
 {
-#ifdef JS_ION
     if (updateJit == UpdateJit && needs != jitUsingBarriers_) {
         jit::ToggleBarriers(this, needs);
         jitUsingBarriers_ = needs;
     }
-#endif
 
     if (needs && runtimeFromMainThread()->isAtomsZone(this))
         JS_ASSERT(!runtimeFromMainThread()->exclusiveThreadsPresent());
 
     JS_ASSERT_IF(needs, canCollect());
     needsBarrier_ = needs;
 }
 
@@ -167,31 +161,30 @@ Zone::sweepBreakpoints(FreeOp *fop)
             }
         }
     }
 }
 
 void
 Zone::discardJitCode(FreeOp *fop)
 {
-#ifdef JS_ION
     if (!jitZone())
         return;
 
     if (isPreservingCode()) {
         PurgeJITCaches(this);
     } else {
 
-# ifdef DEBUG
+#ifdef DEBUG
         /* Assert no baseline scripts are marked as active. */
         for (ZoneCellIterUnderGC i(this, FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
             JS_ASSERT_IF(script->hasBaselineScript(), !script->baselineScript()->active());
         }
-# endif
+#endif
 
         /* Mark baseline scripts on the stack as active. */
         jit::MarkActiveBaselineScripts(this);
 
         /* Only mark OSI points if code is being discarded. */
         jit::InvalidateAll(fop, this);
 
         for (ZoneCellIterUnderGC i(this, FINALIZE_SCRIPT); !i.done(); i.next()) {
@@ -210,40 +203,37 @@ Zone::discardJitCode(FreeOp *fop)
              * need to let it warm back up to get information such as which
              * opcodes are setting array holes or accessing getter properties.
              */
             script->resetUseCount();
         }
 
         jitZone()->optimizedStubSpace()->free();
     }
-#endif
 }
 
 uint64_t
 Zone::gcNumber()
 {
     // Zones in use by exclusive threads are not collected, and threads using
     // them cannot access the main runtime's gcNumber without racing.
     return usedByExclusiveThread ? 0 : runtimeFromMainThread()->gc.gcNumber();
 }
 
-#ifdef JS_ION
 js::jit::JitZone *
 Zone::createJitZone(JSContext *cx)
 {
     MOZ_ASSERT(!jitZone_);
 
     if (!cx->runtime()->getJitRuntime(cx))
         return nullptr;
 
     jitZone_ = cx->new_<js::jit::JitZone>();
     return jitZone_;
 }
-#endif
 
 JS::Zone *
 js::ZoneOfObjectFromAnyThread(const JSObject &obj)
 {
     return obj.zoneFromAnyThread();
 }
 
 bool
--- a/js/src/irregexp/NativeRegExpMacroAssembler.h
+++ b/js/src/irregexp/NativeRegExpMacroAssembler.h
@@ -26,18 +26,16 @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_NATIVE_REGEXP_MACRO_ASSEMBLER_H_
 #define V8_NATIVE_REGEXP_MACRO_ASSEMBLER_H_
 
-#ifdef JS_ION
-
 #include "irregexp/RegExpMacroAssembler.h"
 
 namespace js {
 namespace irregexp {
 
 struct InputOutputData
 {
     const void *inputStart;
@@ -215,11 +213,9 @@ class MOZ_STACK_CLASS NativeRegExpMacroA
 
     int32_t register_offset(int register_index) {
         return sizeof(FrameData) + register_index * sizeof(void *);
     }
 };
 
 } }  // namespace js::irregexp
 
-#endif // JS_ION
-
 #endif  // V8_NATIVE_REGEXP_MACRO_ASSEMBLER_H_
--- a/js/src/irregexp/RegExpEngine.cpp
+++ b/js/src/irregexp/RegExpEngine.cpp
@@ -1646,17 +1646,16 @@ irregexp::CompilePattern(JSContext *cx, 
 
     Analysis analysis(cx, ignore_case, is_ascii);
     analysis.EnsureAnalyzed(node);
     if (analysis.has_failed()) {
         JS_ReportError(cx, analysis.errorMessage());
         return RegExpCode();
     }
 
-#ifdef JS_ION
     Maybe<jit::IonContext> ctx;
     Maybe<NativeRegExpMacroAssembler> native_assembler;
     Maybe<InterpretedRegExpMacroAssembler> interpreted_assembler;
 
     RegExpMacroAssembler *assembler;
     if (IsNativeRegExpEnabled(cx)) {
         NativeRegExpMacroAssembler::Mode mode =
             is_ascii ? NativeRegExpMacroAssembler::ASCII
@@ -1664,20 +1663,16 @@ irregexp::CompilePattern(JSContext *cx, 
 
         ctx.construct(cx, (jit::TempAllocator *) nullptr);
         native_assembler.construct(&alloc, shared, cx->runtime(), mode, (data->capture_count + 1) * 2);
         assembler = native_assembler.addr();
     } else {
         interpreted_assembler.construct(&alloc, shared, (data->capture_count + 1) * 2);
         assembler = interpreted_assembler.addr();
     }
-#else // JS_ION
-    InterpretedRegExpMacroAssembler macro_assembler(&alloc, shared, (data->capture_count + 1) * 2);
-    RegExpMacroAssembler *assembler = &macro_assembler;
-#endif // JS_ION
 
     // Inserted here, instead of in Assembler, because it depends on information
     // in the AST that isn't replicated in the Node structure.
     static const int kMaxBacksearchLimit = 1024;
     if (is_end_anchored &&
         !is_start_anchored &&
         max_length < kMaxBacksearchLimit) {
         assembler->SetCurrentPositionFromEnd(max_length);
@@ -1692,32 +1687,28 @@ irregexp::CompilePattern(JSContext *cx, 
     return compiler.Assemble(cx, assembler, node, data->capture_count);
 }
 
 template <typename CharT>
 RegExpRunStatus
 irregexp::ExecuteCode(JSContext *cx, jit::JitCode *codeBlock, const CharT *chars, size_t start,
                       size_t length, MatchPairs *matches)
 {
-#ifdef JS_ION
     typedef void (*RegExpCodeSignature)(InputOutputData *);
 
     InputOutputData data(chars, chars + length, start, matches);
 
     RegExpCodeSignature function = reinterpret_cast<RegExpCodeSignature>(codeBlock->raw());
 
     {
         JS::AutoSuppressGCAnalysis nogc;
         CALL_GENERATED_REGEXP(function, &data);
     }
 
     return (RegExpRunStatus) data.result;
-#else
-    MOZ_CRASH();
-#endif
 }
 
 template RegExpRunStatus
 irregexp::ExecuteCode(JSContext *cx, jit::JitCode *codeBlock, const Latin1Char *chars, size_t start,
                       size_t length, MatchPairs *matches);
 
 template RegExpRunStatus
 irregexp::ExecuteCode(JSContext *cx, jit::JitCode *codeBlock, const jschar *chars, size_t start,
--- a/js/src/irregexp/RegExpEngine.h
+++ b/js/src/irregexp/RegExpEngine.h
@@ -64,46 +64,30 @@ struct RegExpCompileData
     RegExpTree *tree;
     bool simple;
     bool contains_anchor;
     int capture_count;
 };
 
 struct RegExpCode
 {
-#ifdef JS_ION
     jit::JitCode *jitCode;
     uint8_t *byteCode;
 
     RegExpCode()
       : jitCode(nullptr), byteCode(nullptr)
     {}
 
     bool empty() {
         return !jitCode && !byteCode;
     }
 
     void destroy() {
         js_free(byteCode);
     }
-#else
-    uint8_t *byteCode;
-
-    RegExpCode()
-      : byteCode(nullptr)
-    {}
-
-    bool empty() {
-        return !byteCode;
-    }
-
-    void destroy() {
-        js_free(byteCode);
-    }
-#endif
 };
 
 RegExpCode
 CompilePattern(JSContext *cx, RegExpShared *shared, RegExpCompileData *data,
                HandleLinearString sample,  bool is_global, bool ignore_case = false,
                bool is_ascii = false);
 
 // Note: this may return RegExpRunStatus_Error if an interrupt was requested
--- a/js/src/jit/AsmJS.h
+++ b/js/src/jit/AsmJS.h
@@ -68,35 +68,21 @@ static const size_t AsmJSBufferProtected
 //   | waste | ObjectElements | data array | inaccessible reserved memory |
 //                            ^            ^                              ^
 //                            |            \                             /
 //                      obj->elements       required to be page boundaries
 //
 static const size_t AsmJSMappedSize = AsmJSPageSize + AsmJSBufferProtectedSize;
 #endif // JS_CODEGEN_X64
 
-#ifdef JS_ION
-
-// Return whether asm.js optimization is inhibitted by the platform or
+// Return whether asm.js optimization is inhibited by the platform or
 // dynamically disabled:
 extern bool
 IsAsmJSCompilationAvailable(JSContext *cx, unsigned argc, JS::Value *vp);
 
-#else // JS_ION
-
-inline bool
-IsAsmJSCompilationAvailable(JSContext *cx, unsigned argc, Value *vp)
-{
-    CallArgs args = CallArgsFromVp(argc, vp);
-    args.rval().set(BooleanValue(false));
-    return true;
-}
-
-#endif // JS_ION
-
 // To succesfully link an asm.js module to an ArrayBuffer heap, the
 // ArrayBuffer's byteLength must be:
 //  - greater or equal to 4096
 //  - either a power of 2 OR a multiple of 16MB
 inline bool
 IsValidAsmJSHeapLength(uint32_t length)
 {
     if (length < 4096)
--- a/js/src/jit/AsmJSLink.h
+++ b/js/src/jit/AsmJSLink.h
@@ -6,18 +6,16 @@
 
 #ifndef jit_AsmJSLink_h
 #define jit_AsmJSLink_h
 
 #include "NamespaceImports.h"
 
 namespace js {
 
-#ifdef JS_ION
-
 // Create a new JSFunction to replace originalFun as the representation of the
 // function defining the succesfully-validated module 'moduleObj'.
 extern JSFunction *
 NewAsmJSModuleFunction(ExclusiveContext *cx, JSFunction *originalFun, HandleObject moduleObj);
 
 // Return whether this is the js::Native returned by NewAsmJSModuleFunction.
 extern bool
 IsAsmJSModuleNative(JSNative native);
@@ -42,69 +40,11 @@ IsAsmJSModuleLoadedFromCache(JSContext *
 extern bool
 IsAsmJSFunction(JSContext *cx, unsigned argc, JS::Value *vp);
 extern bool
 IsAsmJSFunction(HandleFunction fun);
 
 extern JSString *
 AsmJSFunctionToString(JSContext *cx, HandleFunction fun);
 
-#else // JS_ION
-
-inline bool
-IsAsmJSModuleNative(JSNative native)
-{
-    return false;
-}
-
-inline bool
-IsAsmJSFunction(JSContext *cx, unsigned argc, Value *vp)
-{
-    CallArgs args = CallArgsFromVp(argc, vp);
-    args.rval().set(BooleanValue(false));
-    return true;
-}
-
-inline bool
-IsAsmJSFunction(HandleFunction fun)
-{
-    return false;
-}
-
-inline JSString *
-AsmJSFunctionToString(JSContext *cx, HandleFunction fun)
-{
-    return nullptr;
-}
-
-inline bool
-IsAsmJSModule(JSContext *cx, unsigned argc, Value *vp)
-{
-    CallArgs args = CallArgsFromVp(argc, vp);
-    args.rval().set(BooleanValue(false));
-    return true;
-}
-
-inline bool
-IsAsmJSModule(HandleFunction fun)
-{
-    return false;
-}
-
-inline JSString*
-AsmJSModuleToString(JSContext *cx, HandleFunction fun, bool addParenToLambda)
-{
-    return nullptr;
-}
-
-inline bool
-IsAsmJSModuleLoadedFromCache(JSContext *cx, unsigned argc, Value *vp)
-{
-    CallArgs args = CallArgsFromVp(argc, vp);
-    args.rval().set(BooleanValue(false));
-    return true;
-}
-
-#endif // JS_ION
-
 } // namespace js
 
 #endif // jit_AsmJS_h
--- a/js/src/jit/AsmJSModule.h
+++ b/js/src/jit/AsmJSModule.h
@@ -2,18 +2,16 @@
  * 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_AsmJSModule_h
 #define jit_AsmJSModule_h
 
-#ifdef JS_ION
-
 #include "mozilla/Maybe.h"
 #include "mozilla/Move.h"
 #include "mozilla/PodOperations.h"
 
 #include "jsscript.h"
 
 #include "gc/Marking.h"
 #include "jit/AsmJS.h"
@@ -1220,11 +1218,9 @@ class AsmJSModuleObject : public JSObjec
         module().addSizeOfMisc(mallocSizeOf, asmJSModuleCode, asmJSModuleData);
     }
 
     static const Class class_;
 };
 
 }  // namespace js
 
-#endif  // JS_ION
-
 #endif /* jit_AsmJSModule_h */
--- a/js/src/jit/BaselineCompiler.h
+++ b/js/src/jit/BaselineCompiler.h
@@ -2,18 +2,16 @@
  * 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_BaselineCompiler_h
 #define jit_BaselineCompiler_h
 
-#ifdef JS_ION
-
 #include "jit/FixedList.h"
 #if defined(JS_CODEGEN_X86)
 # include "jit/x86/BaselineCompiler-x86.h"
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/BaselineCompiler-x64.h"
 #elif defined(JS_CODEGEN_ARM)
 # include "jit/arm/BaselineCompiler-arm.h"
 #elif defined(JS_CODEGEN_MIPS)
@@ -272,11 +270,9 @@ class BaselineCompiler : public Baseline
     void getScopeCoordinateObject(Register reg);
     Address getScopeCoordinateAddressFromObject(Register objReg, Register reg);
     Address getScopeCoordinateAddress(Register reg);
 };
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineCompiler_h */
--- a/js/src/jit/BaselineDebugModeOSR.h
+++ b/js/src/jit/BaselineDebugModeOSR.h
@@ -2,18 +2,16 @@
  * 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_BaselineDebugModeOSR_h
 #define jit_BaselineDebugModeOSR_h
 
-#ifdef JS_ION
-
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 
 namespace js {
 namespace jit {
 
 // Note that this file and the corresponding .cpp implement debug mode
@@ -96,11 +94,9 @@ struct BaselineDebugModeOSRInfo
 };
 
 bool
 RecompileOnStackBaselineScriptsForDebugMode(JSContext *cx, JSCompartment *comp);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif // jit_BaselineDebugModeOSR_h
--- a/js/src/jit/BaselineFrame-inl.h
+++ b/js/src/jit/BaselineFrame-inl.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_BaselineFrame_inl_h
 #define jit_BaselineFrame_inl_h
 
-#ifdef JS_ION
-
 #include "jit/BaselineFrame.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "vm/ScopeObject.h"
 
 namespace js {
@@ -74,11 +72,9 @@ BaselineFrame::callObj() const
     while (!obj->is<CallObject>())
         obj = obj->enclosingScope();
     return obj->as<CallObject>();
 }
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineFrame_inl_h */
--- a/js/src/jit/BaselineFrame.h
+++ b/js/src/jit/BaselineFrame.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_BaselineFrame_h
 #define jit_BaselineFrame_h
 
-#ifdef JS_ION
-
 #include "jit/IonFrames.h"
 #include "vm/Stack.h"
 
 namespace js {
 namespace jit {
 
 struct BaselineDebugModeOSRInfo;
 
@@ -420,11 +418,9 @@ class BaselineFrame
 };
 
 // Ensure the frame is 8-byte aligned (required on ARM).
 JS_STATIC_ASSERT(((sizeof(BaselineFrame) + BaselineFrame::FramePointerOffset) % 8) == 0);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineFrame_h */
--- a/js/src/jit/BaselineFrameInfo.h
+++ b/js/src/jit/BaselineFrameInfo.h
@@ -2,18 +2,16 @@
  * 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_BaselineFrameInfo_h
 #define jit_BaselineFrameInfo_h
 
-#ifdef JS_ION
-
 #include "mozilla/Alignment.h"
 
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/FixedList.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
@@ -313,11 +311,9 @@ class FrameInfo
 #else
     inline void assertValidState(const BytecodeInfo &info) {}
 #endif
 };
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineFrameInfo_h */
--- a/js/src/jit/BaselineHelpers.h
+++ b/js/src/jit/BaselineHelpers.h
@@ -2,18 +2,16 @@
  * 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_BaselineHelpers_h
 #define jit_BaselineHelpers_h
 
-#ifdef JS_ION
-
 #if defined(JS_CODEGEN_X86)
 # include "jit/x86/BaselineHelpers-x86.h"
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/BaselineHelpers-x64.h"
 #elif defined(JS_CODEGEN_ARM)
 # include "jit/arm/BaselineHelpers-arm.h"
 #elif defined(JS_CODEGEN_MIPS)
 # include "jit/mips/BaselineHelpers-mips.h"
@@ -24,11 +22,9 @@
 #endif
 
 namespace js {
 namespace jit {
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineHelpers_h */
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -2,18 +2,16 @@
  * 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_BaselineIC_h
 #define jit_BaselineIC_h
 
-#ifdef JS_ION
-
 #include "mozilla/Assertions.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 #include "jsgc.h"
 #include "jsopcode.h"
 
 #include "jit/BaselineJIT.h"
@@ -6466,11 +6464,9 @@ IsCacheableDOMProxy(JSObject *obj)
         return false;
 
     return true;
 }
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineIC_h */
--- a/js/src/jit/BaselineInspector.h
+++ b/js/src/jit/BaselineInspector.h
@@ -2,18 +2,16 @@
  * 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_BaselineInspector_h
 #define jit_BaselineInspector_h
 
-#ifdef JS_ION
-
 #include "jit/BaselineIC.h"
 #include "jit/BaselineJIT.h"
 #include "jit/MIR.h"
 
 namespace js {
 namespace jit {
 
 class BaselineInspector;
@@ -119,11 +117,9 @@ class BaselineInspector
 
     JSObject *commonGetPropFunction(jsbytecode *pc, Shape **lastProperty, JSFunction **commonGetter);
     JSObject *commonSetPropFunction(jsbytecode *pc, Shape **lastProperty, JSFunction **commonSetter);
 };
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineInspector_h */
--- a/js/src/jit/BaselineJIT.h
+++ b/js/src/jit/BaselineJIT.h
@@ -2,18 +2,16 @@
  * 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_BaselineJIT_h
 #define jit_BaselineJIT_h
 
-#ifdef JS_ION
-
 #include "mozilla/MemoryReporting.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "ds/LifoAlloc.h"
 #include "jit/Bailouts.h"
 #include "jit/IonCode.h"
@@ -424,11 +422,9 @@ void
 MarkActiveBaselineScripts(Zone *zone);
 
 MethodStatus
 BaselineCompile(JSContext *cx, JSScript *script);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineJIT_h */
--- a/js/src/jit/BaselineRegisters.h
+++ b/js/src/jit/BaselineRegisters.h
@@ -2,18 +2,16 @@
  * 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_BaselineRegisters_h
 #define jit_BaselineRegisters_h
 
-#ifdef JS_ION
-
 #if defined(JS_CODEGEN_X86)
 # include "jit/x86/BaselineRegisters-x86.h"
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/BaselineRegisters-x64.h"
 #elif defined(JS_CODEGEN_ARM)
 # include "jit/arm/BaselineRegisters-arm.h"
 #elif defined(JS_CODEGEN_MIPS)
 # include "jit/mips/BaselineRegisters-mips.h"
@@ -24,11 +22,9 @@
 #endif
 
 namespace js {
 namespace jit {
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_BaselineRegisters_h */
--- a/js/src/jit/CompileWrappers.h
+++ b/js/src/jit/CompileWrappers.h
@@ -2,18 +2,16 @@
  * 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_CompileWrappers_h
 #define jit_CompileWrappers_h
 
-#ifdef JS_ION
-
 #include "jscntxt.h"
 
 namespace js {
 namespace jit {
 
 class JitRuntime;
 
 // During Ion compilation we need access to various bits of the current
@@ -136,15 +134,12 @@ class JitCompileOptions
         return spsSlowAssertionsEnabled_;
     }
 
   private:
     bool cloneSingletons_;
     bool spsSlowAssertionsEnabled_;
 };
 
-
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif // jit_CompileWrappers_h
--- a/js/src/jit/CompilerRoot.h
+++ b/js/src/jit/CompilerRoot.h
@@ -2,18 +2,16 @@
  * 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_CompilerRoot_h
 #define jit_CompilerRoot_h
 
-#ifdef JS_ION
-
 #include "jscntxt.h"
 
 #include "jit/Ion.h"
 #include "jit/IonAllocPolicy.h"
 #include "js/RootingAPI.h"
 
 namespace js {
 namespace jit {
@@ -60,11 +58,9 @@ typedef CompilerRoot<JSFunction*> Compil
 typedef CompilerRoot<JSScript*> CompilerRootScript;
 typedef CompilerRoot<PropertyName*> CompilerRootPropertyName;
 typedef CompilerRoot<Shape*> CompilerRootShape;
 typedef CompilerRoot<Value> CompilerRootValue;
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_CompilerRoot_h */
--- a/js/src/jit/ExecutionMode-inl.h
+++ b/js/src/jit/ExecutionMode-inl.h
@@ -2,18 +2,16 @@
  * 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_ExecutionMode_inl_h
 #define jit_ExecutionMode_inl_h
 
-#ifdef JS_ION
-
 #include "jit/CompileInfo.h"
 
 #include "jsscriptinlines.h"
 
 namespace js {
 namespace jit {
 
 static inline bool
@@ -94,11 +92,9 @@ CompilingOffThread(HandleScript script, 
       default:;
     }
     MOZ_ASSUME_UNREACHABLE("No such execution mode");
 }
 
 } // namespace jit
 } // namespace js
 
-#endif  // JS_ION
-
 #endif /* jit_ExecutionMode_inl_h */
--- a/js/src/jit/Ion.h
+++ b/js/src/jit/Ion.h
@@ -2,18 +2,16 @@
  * 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_Ion_h
 #define jit_Ion_h
 
-#ifdef JS_ION
-
 #include "mozilla/MemoryReporting.h"
 
 #include "jscntxt.h"
 #include "jscompartment.h"
 
 #include "jit/CompileInfo.h"
 #include "jit/CompileWrappers.h"
 #include "jit/JitOptions.h"
@@ -203,11 +201,9 @@ void RequestInterruptForIonCode(JSRuntim
 
 bool RematerializeAllFrames(JSContext *cx, JSCompartment *comp);
 bool UpdateForDebugMode(JSContext *maybecx, JSCompartment *comp,
                         AutoDebugModeInvalidation &invalidate);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_Ion_h */
--- a/js/src/jit/IonAnalysis.h
+++ b/js/src/jit/IonAnalysis.h
@@ -2,18 +2,16 @@
  * 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_IonAnalysis_h
 #define jit_IonAnalysis_h
 
-#ifdef JS_ION
-
 // This file declares various analysis passes that operate on MIR.
 
 #include "jit/IonAllocPolicy.h"
 #include "jit/MIR.h"
 
 namespace js {
 namespace jit {
 
@@ -154,11 +152,9 @@ AnalyzeNewScriptProperties(JSContext *cx
                            Vector<types::TypeNewScript::Initializer> *initializerList);
 
 bool
 AnalyzeArgumentsUsage(JSContext *cx, JSScript *script);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_IonAnalysis_h */
--- a/js/src/jit/IonBuilder.h
+++ b/js/src/jit/IonBuilder.h
@@ -2,18 +2,16 @@
  * 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_IonBuilder_h
 #define jit_IonBuilder_h
 
-#ifdef JS_ION
-
 // This file declares the data structures for building a MIRGraph from a
 // JSScript.
 
 #include "jit/BytecodeAnalysis.h"
 #include "jit/IonOptimizationLevels.h"
 #include "jit/MIR.h"
 #include "jit/MIRGenerator.h"
 #include "jit/MIRGraph.h"
@@ -1063,11 +1061,9 @@ class CallInfo
 
 bool TypeSetIncludes(types::TypeSet *types, MIRType input, types::TypeSet *inputTypes);
 
 bool NeedsPostBarrier(CompileInfo &info, MDefinition *value);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_IonBuilder_h */
--- a/js/src/jit/IonFrames-inl.h
+++ b/js/src/jit/IonFrames-inl.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_IonFrames_inl_h
 #define jit_IonFrames_inl_h
 
-#ifdef JS_ION
-
 #include "jit/IonFrames.h"
 
 #include "jit/JitFrameIterator.h"
 #include "jit/LIR.h"
 #include "vm/ForkJoin.h"
 
 #include "jit/JitFrameIterator-inl.h"
 
@@ -92,11 +90,9 @@ inline JSScript *
 GetTopIonJSScript(ForkJoinContext *cx, void **returnAddrOut = nullptr)
 {
     return GetTopIonJSScript(cx->perThreadData->jitTop, returnAddrOut, ParallelExecution);
 }
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_IonFrames_inl_h */
--- a/js/src/jit/IonFrames.h
+++ b/js/src/jit/IonFrames.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_IonFrames_h
 #define jit_IonFrames_h
 
-#ifdef JS_ION
-
 #include <stdint.h>
 
 #include "jscntxt.h"
 #include "jsfun.h"
 
 #include "jit/JitFrameIterator.h"
 
 namespace js {
@@ -865,11 +863,9 @@ void
 GetPcScript(JSContext *cx, JSScript **scriptRes, jsbytecode **pcRes);
 
 CalleeToken
 MarkCalleeToken(JSTracer *trc, CalleeToken token);
 
 } /* namespace jit */
 } /* namespace js */
 
-#endif // JS_ION
-
 #endif /* jit_IonFrames_h */
--- a/js/src/jit/IonMacroAssembler.h
+++ b/js/src/jit/IonMacroAssembler.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_IonMacroAssembler_h
 #define jit_IonMacroAssembler_h
 
-#ifdef JS_ION
-
 #include "jscompartment.h"
 
 #if defined(JS_CODEGEN_X86)
 # include "jit/x86/MacroAssembler-x86.h"
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/MacroAssembler-x64.h"
 #elif defined(JS_CODEGEN_ARM)
 # include "jit/arm/MacroAssembler-arm.h"
@@ -1514,11 +1512,9 @@ StackDecrementForCall(size_t bytesAlread
 {
     return bytesToPush +
            ComputeByteAlignment(bytesAlreadyPushed + bytesToPush, StackAlignment);
 }
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_IonMacroAssembler_h */
--- a/js/src/jit/IonOptimizationLevels.h
+++ b/js/src/jit/IonOptimizationLevels.h
@@ -19,18 +19,16 @@ namespace jit {
 enum OptimizationLevel
 {
     Optimization_DontCompile,
     Optimization_Normal,
     Optimization_AsmJS,
     Optimization_Count
 };
 
-#ifdef JS_ION
-
 #ifdef DEBUG
 inline const char *
 OptimizationLevelString(OptimizationLevel level)
 {
     switch (level) {
       case Optimization_DontCompile:
         return "Optimization_DontCompile";
       case Optimization_Normal:
@@ -216,14 +214,12 @@ class OptimizationInfos
     OptimizationLevel nextLevel(OptimizationLevel level) const;
     OptimizationLevel firstLevel() const;
     bool isLastLevel(OptimizationLevel level) const;
     OptimizationLevel levelForScript(JSScript *script, jsbytecode *pc = nullptr) const;
 };
 
 extern OptimizationInfos js_IonOptimizations;
 
-#endif // JS_ION
-
 } // namespace jit
 } // namespace js
 
 #endif /* jit_IonOptimizationLevels_h */
--- a/js/src/jit/IonTypes.h
+++ b/js/src/jit/IonTypes.h
@@ -408,25 +408,25 @@ IsFloatingPointType(MIRType type)
 
 static inline bool
 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
 
 // Make sure registers are not modified between an instruction and
 // its OsiPoint.
-#  if defined(JS_ION)
-#    define CHECK_OSIPOINT_REGISTERS 1
-#  endif
-#endif
+#define CHECK_OSIPOINT_REGISTERS 1
+
+#endif // DEBUG
 
 enum {
     ArgType_General = 0x1,
     ArgType_Double  = 0x2,
     ArgType_Float32 = 0x3,
 
     RetType_Shift   = 0x0,
     ArgType_Shift   = 0x2,
--- a/js/src/jit/JitCompartment.h
+++ b/js/src/jit/JitCompartment.h
@@ -2,18 +2,16 @@
  * 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_JitCompartment_h
 #define jit_JitCompartment_h
 
-#ifdef JS_ION
-
 #include "mozilla/MemoryReporting.h"
 
 #include "jsweakcache.h"
 
 #include "jit/CompileInfo.h"
 #include "jit/IonCode.h"
 #include "jit/IonFrames.h"
 #include "jit/shared/Assembler-shared.h"
@@ -503,11 +501,9 @@ void FinishInvalidation(FreeOp *fop, JSS
 // The following constant defines the minimum increment of the touch.
 #ifdef XP_WIN
 const unsigned WINDOWS_BIG_FRAME_TOUCH_INCREMENT = 4096 - 1;
 #endif
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_JitCompartment_h */
--- a/js/src/jit/JitFrameIterator-inl.h
+++ b/js/src/jit/JitFrameIterator-inl.h
@@ -2,18 +2,16 @@
  * 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_JitFrameIterator_inl_h
 #define jit_JitFrameIterator_inl_h
 
-#ifdef JS_ION
-
 #include "jit/JitFrameIterator.h"
 
 #include "jit/Bailouts.h"
 #include "jit/BaselineFrame.h"
 #include "jit/IonFrames.h"
 
 namespace js {
 namespace jit {
@@ -32,11 +30,9 @@ JitFrameIterator::isExitFrameLayout() co
     if (type_ != JitFrame_Exit || isFakeExitFrame())
         return false;
     return exitFrame()->is<T>();
 }
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_JitFrameIterator_inl_h */
--- a/js/src/jit/JitFrameIterator.h
+++ b/js/src/jit/JitFrameIterator.h
@@ -2,18 +2,16 @@
  * 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_JitFrameIterator_h
 #define jit_JitFrameIterator_h
 
-#ifdef JS_ION
-
 #include "jsfun.h"
 #include "jsscript.h"
 #include "jstypes.h"
 
 #include "jit/IonCode.h"
 #include "jit/Snapshots.h"
 
 namespace js {
@@ -689,11 +687,9 @@ class InlineFrameIterator
   private:
     InlineFrameIterator() MOZ_DELETE;
     InlineFrameIterator(const InlineFrameIterator &iter) MOZ_DELETE;
 };
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_JitFrameIterator_h */
--- a/js/src/jit/JitOptions.h
+++ b/js/src/jit/JitOptions.h
@@ -5,18 +5,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_JitOptions_h
 #define jit_JitOptions_h
 
 #include "jit/IonTypes.h"
 #include "js/TypeDecls.h"
 
-#ifdef JS_ION
-
 namespace js {
 namespace jit {
 
 // Longer scripts can only be compiled off thread, as these compilations
 // can be expensive and stall the main thread for too long.
 static const uint32_t MAX_OFF_THREAD_SCRIPT_SIZE = 100 * 1000;
 static const uint32_t MAX_MAIN_THREAD_SCRIPT_SIZE = 2 * 1000;
 static const uint32_t MAX_MAIN_THREAD_LOCALS_AND_ARGS = 256;
@@ -66,11 +64,9 @@ struct JitOptions
     void resetUsesBeforeCompile();
 };
 
 extern JitOptions js_JitOptions;
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_JitOptions_h */
--- a/js/src/jit/RematerializedFrame.h
+++ b/js/src/jit/RematerializedFrame.h
@@ -2,18 +2,16 @@
  * 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_RematerializedFrame_h
 #define jit_RematerializedFrame_h
 
-#ifdef JS_ION
-
 #include "jsfun.h"
 
 #include "jit/JitFrameIterator.h"
 
 #include "vm/Stack.h"
 
 namespace js {
 namespace jit {
@@ -177,10 +175,9 @@ class RematerializedFrame
 
     void mark(JSTracer *trc);
     void dump();
 };
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
 #endif // jit_RematerializedFrame_h
--- a/js/src/jit/ScalarReplacement.h
+++ b/js/src/jit/ScalarReplacement.h
@@ -3,25 +3,21 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // This file declares scalar replacement of objects transformation.
 #ifndef jit_ScalarReplacement_h
 #define jit_ScalarReplacement_h
 
-#ifdef JS_ION
-
 namespace js {
 namespace jit {
 
 class MIRGenerator;
 class MIRGraph;
 
 bool
 ScalarReplacement(MIRGenerator *mir, MIRGraph &graph);
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_ScalarReplacement_h */
--- a/js/src/jit/arm/BaselineHelpers-arm.h
+++ b/js/src/jit/arm/BaselineHelpers-arm.h
@@ -2,17 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_BaselineHelpers_arm_h
 #define jit_arm_BaselineHelpers_arm_h
 
-#ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
@@ -312,12 +311,9 @@ EmitStubGuardFailure(MacroAssembler &mas
     JS_ASSERT(BaselineTailCallReg == lr);
     masm.branch(r0);
 }
 
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_arm_BaselineHelpers_arm_h */
-
--- a/js/src/jit/arm/BaselineRegisters-arm.h
+++ b/js/src/jit/arm/BaselineRegisters-arm.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_arm_BaselineRegisters_arm_h
 #define jit_arm_BaselineRegisters_arm_h
 
-#ifdef JS_ION
-
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 // r15 = program-counter
 // r14 = link-register
 
@@ -48,11 +46,9 @@ static MOZ_CONSTEXPR_VAR Register Baseli
 
 // FloatReg0 must be equal to ReturnFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = d0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = d1;
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_arm_BaselineRegisters_arm_h */
--- a/js/src/jit/mips/BaselineHelpers-mips.h
+++ b/js/src/jit/mips/BaselineHelpers-mips.h
@@ -2,17 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_mips_BaselineHelpers_mips_h
 #define jit_mips_BaselineHelpers_mips_h
 
-#ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
@@ -322,12 +321,9 @@ EmitStubGuardFailure(MacroAssembler &mas
     MOZ_ASSERT(BaselineTailCallReg == ra);
     masm.branch(R2.scratchReg());
 }
 
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_mips_BaselineHelpers_mips_h */
-
--- a/js/src/jit/mips/BaselineRegisters-mips.h
+++ b/js/src/jit/mips/BaselineRegisters-mips.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_mips_BaselineRegisters_mips_h
 #define jit_mips_BaselineRegisters_mips_h
 
-#ifdef JS_ION
-
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = s5;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = sp;
 
@@ -38,12 +36,9 @@ static MOZ_CONSTEXPR_VAR Register Baseli
 
 // FloatReg0 must be equal to ReturnFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0 = f0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1 = f2;
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_mips_BaselineRegisters_mips_h */
-
--- a/js/src/jit/x64/BaselineHelpers-x64.h
+++ b/js/src/jit/x64/BaselineHelpers-x64.h
@@ -2,17 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_BaselineHelpers_x64_h
 #define jit_x64_BaselineHelpers_x64_h
 
-#ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
@@ -279,15 +278,12 @@ EmitStubGuardFailure(MacroAssembler &mas
 
     // Load next stub into BaselineStubReg
     masm.loadPtr(Address(BaselineStubReg, ICStub::offsetOfNext()), BaselineStubReg);
 
     // Return address is already loaded, just jump to the next stubcode.
     masm.jmp(Operand(BaselineStubReg, ICStub::offsetOfStubCode()));
 }
 
-
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_x64_BaselineHelpers_x64_h */
--- a/js/src/jit/x64/BaselineRegisters-x64.h
+++ b/js/src/jit/x64/BaselineRegisters-x64.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x64_BaselineRegisters_x64_h
 #define jit_x64_BaselineRegisters_x64_h
 
-#ifdef JS_ION
-
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg    = rbp;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg    = rsp;
 
@@ -29,11 +27,9 @@ static MOZ_CONSTEXPR_VAR Register Extrac
 
 // FloatReg0 must be equal to ReturnFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = xmm0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = xmm1;
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_x64_BaselineRegisters_x64_h */
--- a/js/src/jit/x86/BaselineHelpers-x86.h
+++ b/js/src/jit/x86/BaselineHelpers-x86.h
@@ -2,17 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_BaselineHelpers_x86_h
 #define jit_x86_BaselineHelpers_x86_h
 
-#ifdef JS_ION
 #include "jit/BaselineFrame.h"
 #include "jit/BaselineIC.h"
 #include "jit/BaselineRegisters.h"
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
@@ -289,11 +288,9 @@ EmitStubGuardFailure(MacroAssembler &mas
     // Return address is already loaded, just jump to the next stubcode.
     masm.jmp(Operand(BaselineStubReg, (int32_t) ICStub::offsetOfStubCode()));
 }
 
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_x86_BaselineHelpers_x86_h */
--- a/js/src/jit/x86/BaselineRegisters-x86.h
+++ b/js/src/jit/x86/BaselineRegisters-x86.h
@@ -2,18 +2,16 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_x86_BaselineRegisters_x86_h
 #define jit_x86_BaselineRegisters_x86_h
 
-#ifdef JS_ION
-
 #include "jit/IonMacroAssembler.h"
 
 namespace js {
 namespace jit {
 
 static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = ebp;
 static MOZ_CONSTEXPR_VAR Register BaselineStackReg = esp;
 
@@ -32,11 +30,9 @@ static MOZ_CONSTEXPR_VAR Register Extrac
 
 // FloatReg0 must be equal to ReturnFloatReg.
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = xmm0;
 static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = xmm1;
 
 } // namespace jit
 } // namespace js
 
-#endif // JS_ION
-
 #endif /* jit_x86_BaselineRegisters_x86_h */
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -581,20 +581,18 @@ JS_Init(void)
     CheckMessageNumbering();
     CheckMessageParameterCounts();
 #endif
 
     using js::TlsPerThreadData;
     if (!TlsPerThreadData.initialized() && !TlsPerThreadData.init())
         return false;
 
-#if defined(JS_ION)
     if (!jit::InitializeIon())
         return false;
-#endif
 
     if (!ForkJoinContext::initializeTls())
         return false;
 
 #if EXPOSE_INTL_API
     UErrorCode err = U_ZERO_ERROR;
     u_init(&err);
     if (U_FAILURE(err))
@@ -2057,27 +2055,25 @@ js::RecomputeStackLimit(JSRuntime *rt, S
 #endif
 
     // If there's no pending interrupt request set on the runtime's main thread's
     // jitStackLimit, then update it so that it reflects the new nativeStacklimit.
     //
     // Note that, for now, we use the untrusted limit for ion. This is fine,
     // because it's the most conservative limit, and if we hit it, we'll bail
     // out of ion into the interpeter, which will do a proper recursion check.
-#ifdef JS_ION
     if (kind == StackForUntrustedScript) {
         JSRuntime::AutoLockForInterrupt lock(rt);
         if (rt->mainThread.jitStackLimit != uintptr_t(-1)) {
             rt->mainThread.jitStackLimit = rt->mainThread.nativeStackLimit[kind];
 #if defined(JS_ARM_SIMULATOR) || defined(JS_MIPS_SIMULATOR)
             rt->mainThread.jitStackLimit = jit::Simulator::StackLimit();
 #endif
         }
     }
-#endif
 }
 
 JS_PUBLIC_API(void)
 JS_SetNativeStackQuota(JSRuntime *rt, size_t systemCodeStackSize,
                        size_t trustedScriptStackSize,
                        size_t untrustedScriptStackSize)
 {
     JS_ASSERT_IF(trustedScriptStackSize,
@@ -6184,34 +6180,28 @@ JS_ScheduleGC(JSContext *cx, uint32_t co
 {
     cx->runtime()->gc.setNextScheduled(count);
 }
 #endif
 
 JS_PUBLIC_API(void)
 JS_SetParallelParsingEnabled(JSRuntime *rt, bool enabled)
 {
-#ifdef JS_ION
     rt->setParallelParsingEnabled(enabled);
-#endif
 }
 
 JS_PUBLIC_API(void)
 JS_SetOffthreadIonCompilationEnabled(JSRuntime *rt, bool enabled)
 {
-#ifdef JS_ION
     rt->setOffthreadIonCompilationEnabled(enabled);
-#endif
 }
 
 JS_PUBLIC_API(void)
 JS_SetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt, uint32_t value)
 {
-#ifdef JS_ION
-
     switch (opt) {
       case JSJITCOMPILER_BASELINE_USECOUNT_TRIGGER:
         if (value == uint32_t(-1)) {
             jit::JitOptions defaultValues;
             value = defaultValues.baselineUsesBeforeCompile;
         }
         jit::js_JitOptions.baselineUsesBeforeCompile = value;
         break;
@@ -6258,17 +6248,16 @@ JS_SetGlobalJitCompilerOption(JSRuntime 
         } else if (value == 0) {
             rt->setCanUseSignalHandlers(false);
             IonSpew(js::jit::IonSpew_Scripts, "Disable signals");
         }
         break;
       default:
         break;
     }
-#endif
 }
 
 JS_PUBLIC_API(int)
 JS_GetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt)
 {
 #ifndef JS_CODEGEN_NONE
     switch (opt) {
       case JSJITCOMPILER_BASELINE_USECOUNT_TRIGGER:
--- a/js/src/jsarray.cpp
+++ b/js/src/jsarray.cpp
@@ -2570,17 +2570,16 @@ js::array_splice_impl(JSContext *cx, uns
 
     /* Step 17. */
     if (returnValueIsUsed)
         args.rval().setObject(*arr);
 
     return true;
 }
 
-#ifdef JS_ION
 bool
 js::array_concat_dense(JSContext *cx, Handle<ArrayObject*> arr1, Handle<ArrayObject*> arr2,
                        Handle<ArrayObject*> result)
 {
     uint32_t initlen1 = arr1->getDenseInitializedLength();
     JS_ASSERT(initlen1 == arr1->length());
 
     uint32_t initlen2 = arr2->getDenseInitializedLength();
@@ -2595,17 +2594,16 @@ js::array_concat_dense(JSContext *cx, Ha
     JS_ASSERT(!result->getDenseInitializedLength());
     result->setDenseInitializedLength(len);
 
     result->initDenseElements(0, arr1->getDenseElements(), initlen1);
     result->initDenseElements(initlen1, arr2->getDenseElements(), initlen2);
     result->setLengthInt32(len);
     return true;
 }
-#endif /* JS_ION */
 
 /*
  * Python-esque sequence operations.
  */
 bool
 js::array_concat(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
--- a/js/src/jscntxt.cpp
+++ b/js/src/jscntxt.cpp
@@ -34,19 +34,17 @@
 #include "jsprf.h"
 #include "jspubtd.h"
 #include "jsscript.h"
 #include "jsstr.h"
 #include "jstypes.h"
 #include "jswatchpoint.h"
 
 #include "gc/Marking.h"
-#ifdef JS_ION
 #include "jit/Ion.h"
-#endif
 #include "js/CharacterEncoding.h"
 #include "js/OldDebugAPI.h"
 #include "vm/Debugger.h"
 #include "vm/HelperThreads.h"
 #include "vm/Shape.h"
 
 #include "jsobjinlines.h"
 #include "jsscriptinlines.h"
@@ -985,23 +983,21 @@ js::InvokeInterruptCallback(JSContext *c
     rt->interrupt = false;
 
     // IonMonkey sets its stack limit to UINTPTR_MAX to trigger interrupt
     // callbacks.
     rt->resetJitStackLimit();
 
     js::gc::GCIfNeeded(cx);
 
-#ifdef JS_ION
     rt->interruptPar = false;
 
     // A worker thread may have requested an interrupt after finishing an Ion
     // compilation.
     jit::AttachFinishedCompilations(cx);
-#endif
 
     // Important: Additional callbacks can occur inside the callback handler
     // if it re-enters the JS engine. The embedding must ensure that the
     // callback is disconnected before attempting such re-entry.
     JSInterruptCallback cb = cx->runtime()->interruptCallback;
     if (!cb)
         return true;
 
--- a/js/src/jscntxtinlines.h
+++ b/js/src/jscntxtinlines.h
@@ -460,28 +460,26 @@ JSContext::currentScript(jsbytecode **pp
     while (act && (act->cx() != this || (act->isJit() && !act->asJit()->isActive())))
         act = act->prev();
 
     if (!act)
         return nullptr;
 
     JS_ASSERT(act->cx() == this);
 
-#ifdef JS_ION
     if (act->isJit()) {
         JSScript *script = nullptr;
         js::jit::GetPcScript(const_cast<JSContext *>(this), &script, ppc);
         if (!allowCrossCompartment && script->compartment() != compartment())
             return nullptr;
         return script;
     }
 
     if (act->isAsmJS())
         return nullptr;
-#endif
 
     JS_ASSERT(act->isInterpreter());
 
     js::InterpreterFrame *fp = act->asInterpreter()->current();
     JS_ASSERT(!fp->runningInJit());
 
     JSScript *script = fp->script();
     if (!allowCrossCompartment && script->compartment() != compartment())
--- a/js/src/jscompartment.cpp
+++ b/js/src/jscompartment.cpp
@@ -13,19 +13,17 @@
 #include "jsfriendapi.h"
 #include "jsgc.h"
 #include "jsiter.h"
 #include "jsproxy.h"
 #include "jswatchpoint.h"
 #include "jswrapper.h"
 
 #include "gc/Marking.h"
-#ifdef JS_ION
 #include "jit/JitCompartment.h"
-#endif
 #include "js/RootingAPI.h"
 #include "vm/StopIterationObject.h"
 #include "vm/WrapperObject.h"
 
 #include "jsatominlines.h"
 #include "jsfuninlines.h"
 #include "jsgcinlines.h"
 #include "jsinferinlines.h"
@@ -61,31 +59,26 @@ JSCompartment::JSCompartment(Zone *zone,
     gcWeakMapList(nullptr),
     debugModeBits(runtime_->debugMode ? DebugFromC : 0),
     rngState(0),
     watchpointMap(nullptr),
     scriptCountsMap(nullptr),
     debugScriptMap(nullptr),
     debugScopes(nullptr),
     enumerators(nullptr),
-    compartmentStats(nullptr)
-#ifdef JS_ION
-    , jitCompartment_(nullptr)
-#endif
+    compartmentStats(nullptr),
+    jitCompartment_(nullptr)
 {
     runtime_->numCompartments++;
     JS_ASSERT_IF(options.mergeable(), options.invisibleToDebugger());
 }
 
 JSCompartment::~JSCompartment()
 {
-#ifdef JS_ION
     js_delete(jitCompartment_);
-#endif
-
     js_delete(watchpointMap);
     js_delete(scriptCountsMap);
     js_delete(debugScriptMap);
     js_delete(debugScopes);
     js_free(enumerators);
 
     runtime_->numCompartments--;
 }
@@ -115,17 +108,16 @@ JSCompartment::init(JSContext *cx)
         return false;
 
     if (!savedStacks_.init())
         return false;
 
     return debuggees.init(0);
 }
 
-#ifdef JS_ION
 jit::JitRuntime *
 JSRuntime::createJitRuntime(JSContext *cx)
 {
     // The shared stubs are created in the atoms compartment, which may be
     // accessed by other threads with an exclusive context.
     AutoLockForExclusiveAccess atomsLock(cx);
 
     // The runtime will only be created on its owning thread, but reads of a
@@ -175,17 +167,16 @@ JSCompartment::ensureJitCompartmentExist
     if (!jitCompartment_->initialize(cx)) {
         js_delete(jitCompartment_);
         jitCompartment_ = nullptr;
         return false;
     }
 
     return true;
 }
-#endif
 
 #ifdef JSGC_GENERATIONAL
 
 /*
  * This class is used to add a post barrier on the crossCompartmentWrappers map,
  * as the key is calculated based on objects which may be moved by generational
  * GC.
  */
@@ -559,20 +550,18 @@ JSCompartment::trace(JSTracer *trc)
     savedStacks_.trace(trc);
 }
 
 void
 JSCompartment::markRoots(JSTracer *trc)
 {
     JS_ASSERT(!trc->runtime()->isHeapMinorCollecting());
 
-#ifdef JS_ION
     if (jitCompartment_)
         jitCompartment_->mark(trc, this);
-#endif
 
     /*
      * If a compartment is on-stack, we mark its global so that
      * JSContext::global() remains valid.
      */
     if (enterCompartmentDepth && global_)
         MarkObjectRoot(trc, global_.unsafeGet(), "on-stack compartment global");
 }
@@ -603,20 +592,18 @@ JSCompartment::sweep(FreeOp *fop, bool r
             global_.set(nullptr);
 
         if (selfHostingScriptSource &&
             IsObjectAboutToBeFinalized((JSObject **) selfHostingScriptSource.unsafeGet()))
         {
             selfHostingScriptSource.set(nullptr);
         }
 
-#ifdef JS_ION
         if (jitCompartment_)
             jitCompartment_->sweep(fop, this);
-#endif
 
         /*
          * JIT code increments activeUseCount for any RegExpShared used by jit
          * code for the lifetime of the JIT script. Thus, we must perform
          * sweeping after clearing jit code.
          */
         regExps.sweep(rt);
 
@@ -678,19 +665,17 @@ JSCompartment::clearTables()
 {
     global_.set(nullptr);
 
     // No scripts should have run in this compartment. This is used when
     // merging a compartment that has been used off thread into another
     // compartment and zone.
     JS_ASSERT(crossCompartmentWrappers.empty());
     JS_ASSERT_IF(callsiteClones.initialized(), callsiteClones.empty());
-#ifdef JS_ION
     JS_ASSERT(!jitCompartment_);
-#endif
     JS_ASSERT(!debugScopes);
     JS_ASSERT(!gcWeakMapList);
     JS_ASSERT(enumerators->next() == enumerators);
     JS_ASSERT(regExps.empty());
 
     types.clearTables();
     if (baseShapes.initialized())
         baseShapes.clear();
@@ -830,25 +815,21 @@ JSCompartment::setDebugModeFromC(JSConte
             DebugScopes::onCompartmentLeaveDebugMode(this);
     }
     return true;
 }
 
 bool
 JSCompartment::updateJITForDebugMode(JSContext *maybecx, AutoDebugModeInvalidation &invalidate)
 {
-#ifdef JS_ION
     // The AutoDebugModeInvalidation argument makes sure we can't forget to
     // invalidate, but it is also important not to run any scripts in this
     // compartment until the invalidate is destroyed.  That is the caller's
     // responsibility.
-    if (!jit::UpdateForDebugMode(maybecx, this, invalidate))
-        return false;
-#endif
-    return true;
+    return jit::UpdateForDebugMode(maybecx, this, invalidate);
 }
 
 bool
 JSCompartment::addDebuggee(JSContext *cx, js::GlobalObject *global)
 {
     AutoDebugModeInvalidation invalidate(this);
     return addDebuggee(cx, global, invalidate);
 }
--- a/js/src/jscompartment.h
+++ b/js/src/jscompartment.h
@@ -446,26 +446,24 @@ struct JSCompartment
      * List of potentially active iterators that may need deleted property
      * suppression.
      */
     js::NativeIterator *enumerators;
 
     /* Used by memory reporters and invalid otherwise. */
     void               *compartmentStats;
 
-#ifdef JS_ION
   private:
     js::jit::JitCompartment *jitCompartment_;
 
   public:
     bool ensureJitCompartmentExists(JSContext *cx);
     js::jit::JitCompartment *jitCompartment() {
         return jitCompartment_;
     }
-#endif
 };
 
 inline bool
 JSRuntime::isAtomsZone(JS::Zone *zone)
 {
     return zone == atomsCompartment_->zone();
 }
 
@@ -500,21 +498,17 @@ class js::AutoDebugModeInvalidation
     explicit AutoDebugModeInvalidation(JSCompartment *comp)
       : comp_(comp), zone_(nullptr), needInvalidation_(NoNeed)
     { }
 
     explicit AutoDebugModeInvalidation(JS::Zone *zone)
       : comp_(nullptr), zone_(zone), needInvalidation_(NoNeed)
     { }
 
-#ifdef JS_ION
     ~AutoDebugModeInvalidation();
-#else
-    ~AutoDebugModeInvalidation() { }
-#endif
 
     bool isFor(JSCompartment *comp) {
         if (comp_)
             return comp == comp_;
         return comp->zone() == zone_;
     }
 
     void scheduleInvalidation(bool debugMode) {
--- a/js/src/jsfun.cpp
+++ b/js/src/jsfun.cpp
@@ -27,20 +27,18 @@
 #include "jstypes.h"
 #include "jswrapper.h"
 
 #include "builtin/Eval.h"
 #include "builtin/Object.h"
 #include "frontend/BytecodeCompiler.h"
 #include "frontend/TokenStream.h"
 #include "gc/Marking.h"
-#ifdef JS_ION
 #include "jit/Ion.h"
 #include "jit/JitFrameIterator.h"
-#endif
 #include "vm/Interpreter.h"
 #include "vm/Shape.h"
 #include "vm/StringBuffer.h"
 #include "vm/WrapperObject.h"
 #include "vm/Xdr.h"
 
 #include "jsscriptinlines.h"
 
@@ -93,24 +91,22 @@ fun_getProperty(JSContext *cx, HandleObj
                                           nullptr, JSMSG_DEPRECATED_USAGE, js_arguments_str)) {
             return false;
         }
 
         ArgumentsObject *argsobj = ArgumentsObject::createUnexpected(cx, iter);
         if (!argsobj)
             return false;
 
-#ifdef JS_ION
         // Disabling compiling of this script in IonMonkey.
         // IonMonkey does not guarantee |f.arguments| can be
         // fully recovered, so we try to mitigate observing this behavior by
         // detecting its use early.
         JSScript *script = iter.script();
         jit::ForbidCompilation(cx, script);
-#endif
 
         vp.setObject(*argsobj);
         return true;
     }
 
     if (JSID_IS_ATOM(id, cx->names().caller)) {
         ++iter;
         if (iter.done() || !iter.isFunctionFrame()) {
--- a/js/src/jsgc.cpp
+++ b/js/src/jsgc.cpp
@@ -200,19 +200,17 @@
 #endif
 #include "prmjtime.h"
 
 #include "gc/FindSCCs.h"
 #include "gc/GCInternals.h"
 #include "gc/GCTrace.h"
 #include "gc/Marking.h"
 #include "gc/Memory.h"
-#ifdef JS_ION
-# include "jit/BaselineJIT.h"
-#endif
+#include "jit/BaselineJIT.h"
 #include "jit/IonCode.h"
 #include "js/SliceBudget.h"
 #include "vm/Debugger.h"
 #include "vm/ForkJoin.h"
 #include "vm/ProxyObject.h"
 #include "vm/Shape.h"
 #include "vm/String.h"
 #include "vm/Symbol.h"
@@ -339,45 +337,37 @@ static const AllocKind FinalizePhaseStri
     FINALIZE_EXTERNAL_STRING
 };
 
 static const AllocKind FinalizePhaseScripts[] = {
     FINALIZE_SCRIPT,
     FINALIZE_LAZY_SCRIPT
 };
 
-#ifdef JS_ION
 static const AllocKind FinalizePhaseJitCode[] = {
     FINALIZE_JITCODE
 };
-#endif
 
 static const AllocKind * const FinalizePhases[] = {
     FinalizePhaseStrings,
     FinalizePhaseScripts,
-#ifdef JS_ION
-    FinalizePhaseJitCode,
-#endif
+    FinalizePhaseJitCode
 };
 static const int FinalizePhaseCount = sizeof(FinalizePhases) / sizeof(AllocKind*);
 
 static const int FinalizePhaseLength[] = {
     sizeof(FinalizePhaseStrings) / sizeof(AllocKind),
     sizeof(FinalizePhaseScripts) / sizeof(AllocKind),
-#ifdef JS_ION
-    sizeof(FinalizePhaseJitCode) / sizeof(AllocKind),
-#endif
+    sizeof(FinalizePhaseJitCode) / sizeof(AllocKind)
 };
 
 static const gcstats::Phase FinalizePhaseStatsPhase[] = {
     gcstats::PHASE_SWEEP_STRING,
     gcstats::PHASE_SWEEP_SCRIPT,
-#ifdef JS_ION
-    gcstats::PHASE_SWEEP_JITCODE,
-#endif
+    gcstats::PHASE_SWEEP_JITCODE
 };
 
 /*
  * Finalization order for things swept in the background.
  */
 
 static const AllocKind BackgroundPhaseObjects[] = {
     FINALIZE_OBJECT0_BACKGROUND,
@@ -615,24 +605,22 @@ FinalizeArenas(FreeOp *fop,
         return FinalizeTypedArenas<JSString>(fop, src, dest, thingKind, budget);
       case FINALIZE_FAT_INLINE_STRING:
         return FinalizeTypedArenas<JSFatInlineString>(fop, src, dest, thingKind, budget);
       case FINALIZE_EXTERNAL_STRING:
         return FinalizeTypedArenas<JSExternalString>(fop, src, dest, thingKind, budget);
       case FINALIZE_SYMBOL:
         return FinalizeTypedArenas<JS::Symbol>(fop, src, dest, thingKind, budget);
       case FINALIZE_JITCODE:
-#ifdef JS_ION
       {
         // JitCode finalization may release references on an executable
         // allocator that is accessed when requesting interrupts.
         JSRuntime::AutoLockForInterrupt lock(fop->runtime());
         return FinalizeTypedArenas<jit::JitCode>(fop, src, dest, thingKind, budget);
       }
-#endif
       default:
         MOZ_CRASH("Invalid alloc kind");
     }
 }
 
 static inline Chunk *
 AllocChunk(JSRuntime *rt)
 {
@@ -2123,24 +2111,22 @@ ArenaLists::queueStringsAndSymbolsForSwe
 void
 ArenaLists::queueScriptsForSweep(FreeOp *fop)
 {
     gcstats::AutoPhase ap(fop->runtime()->gc.stats, gcstats::PHASE_SWEEP_SCRIPT);
     queueForForegroundSweep(fop, FINALIZE_SCRIPT);
     queueForForegroundSweep(fop, FINALIZE_LAZY_SCRIPT);
 }
 
-#ifdef JS_ION
 void
 ArenaLists::queueJitCodeForSweep(FreeOp *fop)
 {
     gcstats::AutoPhase ap(fop->runtime()->gc.stats, gcstats::PHASE_SWEEP_JITCODE);
     queueForForegroundSweep(fop, FINALIZE_JITCODE);
 }
-#endif
 
 void
 ArenaLists::queueShapesForSweep(FreeOp *fop)
 {
     gcstats::AutoPhase ap(fop->runtime()->gc.stats, gcstats::PHASE_SWEEP_SHAPE);
 
     queueForBackgroundSweep(fop, FINALIZE_SHAPE);
     queueForBackgroundSweep(fop, FINALIZE_BASE_SHAPE);
@@ -3035,20 +3021,18 @@ GCRuntime::shouldPreserveJITCode(JSCompa
 
     if (alwaysPreserveCode)
         return true;
     if (comp->lastAnimationTime + PRMJ_USEC_PER_SEC >= currentTime)
         return true;
     if (reason == JS::gcreason::DEBUG_GC)
         return true;
 
-#ifdef JS_ION
     if (comp->jitCompartment() && comp->jitCompartment()->hasRecentParallelActivity())
         return true;
-#endif
 
     return false;
 }
 
 #ifdef DEBUG
 class CompartmentCheckTracer : public JSTracer
 {
   public:
@@ -3186,20 +3170,18 @@ GCRuntime::beginMarkPhase(JS::gcreason::
     for (CompartmentsIter c(rt, WithAtoms); !c.done(); c.next()) {
         JS_ASSERT(c->gcLiveArrayBuffers.empty());
         c->marked = false;
         if (shouldPreserveJITCode(c, currentTime, reason))
             c->zone()->setPreservingCode(true);
     }
 
     if (!rt->gc.cleanUpEverything) {
-#ifdef JS_ION
         if (JSCompartment *comp = jit::TopmostIonActivationCompartment(rt))
             comp->zone()->setPreservingCode(true);
-#endif
     }
 
     /*
      * Atoms are not in the cross-compartment map. So if there are any
      * zones that are not being collected, we are not allowed to collect
      * atoms. Otherwise, the non-collected zones could contain pointers
      * to atoms that we would miss.
      *
@@ -4220,22 +4202,20 @@ GCRuntime::beginSweepingZoneGroup()
     for (GCZoneGroupIter zone(rt); !zone.done(); zone.next()) {
         gcstats::AutoSCC scc(stats, zoneGroupIndex);
         zone->allocator.arenas.queueStringsAndSymbolsForSweep(&fop);
     }
     for (GCZoneGroupIter zone(rt); !zone.done(); zone.next()) {
         gcstats::AutoSCC scc(stats, zoneGroupIndex);
         zone->allocator.arenas.queueScriptsForSweep(&fop);
     }
-#ifdef JS_ION
     for (GCZoneGroupIter zone(rt); !zone.done(); zone.next()) {
         gcstats::AutoSCC scc(stats, zoneGroupIndex);
         zone->allocator.arenas.queueJitCodeForSweep(&fop);
     }
-#endif
     for (GCZoneGroupIter zone(rt); !zone.done(); zone.next()) {
         gcstats::AutoSCC scc(stats, zoneGroupIndex);
         zone->allocator.arenas.queueShapesForSweep(&fop);
         zone->allocator.arenas.gcShapeArenasToSweep =
             zone->allocator.arenas.arenaListsToSweep[FINALIZE_SHAPE];
     }
 
     finalizePhase = 0;
@@ -4447,22 +4427,21 @@ GCRuntime::endSweepPhase(JSGCInvocationK
          * script's filename. See bug 323267.
          */
         if (isFull)
             SweepScriptData(rt);
 
         /* Clear out any small pools that we're hanging on to. */
         if (JSC::ExecutableAllocator *execAlloc = rt->maybeExecAlloc())
             execAlloc->purge();
-#ifdef JS_ION
+
         if (rt->jitRuntime() && rt->jitRuntime()->hasIonAlloc()) {
             JSRuntime::AutoLockForInterrupt lock(rt);
             rt->jitRuntime()->ionAlloc(rt)->purge();
         }
-#endif
 
         /*
          * This removes compartments from rt->compartment, so we do it last to make
          * sure we don't miss sweeping any compartments.
          */
         if (!lastGC)
             sweepZones(&fop, lastGC);
 
@@ -5621,37 +5600,35 @@ void PreventGCDuringInteractiveDebug()
     TlsPerThreadData.get()->suppressGC++;
 }
 
 #endif
 
 void
 js::ReleaseAllJITCode(FreeOp *fop)
 {
-#ifdef JS_ION
-
-# ifdef JSGC_GENERATIONAL
+#ifdef JSGC_GENERATIONAL
     /*
      * Scripts can entrain nursery things, inserting references to the script
      * into the store buffer. Clear the store buffer before discarding scripts.
      */
     MinorGC(fop->runtime(), JS::gcreason::EVICT_NURSERY);
-# endif
+#endif
 
     for (ZonesIter zone(fop->runtime(), SkipAtoms); !zone.done(); zone.next()) {
         if (!zone->jitZone())
             continue;
 
-# ifdef DEBUG
+#ifdef DEBUG
         /* Assert no baseline scripts are marked as active. */
         for (ZoneCellIter i(zone, FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
             JS_ASSERT_IF(script->hasBaselineScript(), !script->baselineScript()->active());
         }
-# endif
+#endif
 
         /* Mark baseline scripts on the stack as active. */
         jit::MarkActiveBaselineScripts(zone);
 
         jit::InvalidateAll(fop, zone);
 
         for (ZoneCellIter i(zone, FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
@@ -5662,30 +5639,27 @@ js::ReleaseAllJITCode(FreeOp *fop)
              * Discard baseline script if it's not marked as active. Note that
              * this also resets the active flag.
              */
             jit::FinishDiscardBaselineScript(fop, script);
         }
 
         zone->jitZone()->optimizedStubSpace()->free();
     }
-#endif
 }
 
 void
 js::PurgeJITCaches(Zone *zone)
 {
-#ifdef JS_ION
     for (ZoneCellIterUnderGC i(zone, FINALIZE_SCRIPT); !i.done(); i.next()) {
         JSScript *script = i.get<JSScript>();
 
         /* Discard Ion caches. */
         jit::PurgeCaches(script);
     }
-#endif
 }
 
 void
 ArenaLists::normalizeBackgroundFinalizeState(AllocKind thingKind)
 {
     ArenaLists::BackgroundFinalizeState *bfs = &backgroundFinalizeState[thingKind];
     switch (*bfs) {
       case BFS_DONE:
--- a/js/src/jsgc.h
+++ b/js/src/jsgc.h
@@ -914,19 +914,17 @@ class ArenaLists
     void checkEmptyFreeList(AllocKind kind) {
         JS_ASSERT(freeLists[kind].isEmpty());
     }
 
     void queueObjectsForSweep(FreeOp *fop);
     void queueStringsAndSymbolsForSweep(FreeOp *fop);
     void queueShapesForSweep(FreeOp *fop);
     void queueScriptsForSweep(FreeOp *fop);
-#ifdef JS_ION
     void queueJitCodeForSweep(FreeOp *fop);
-#endif
 
     bool foregroundFinalize(FreeOp *fop, AllocKind thingKind, SliceBudget &sliceBudget,
                             SortedArenaList &sweepList);
     static void backgroundFinalize(FreeOp *fop, ArenaHeader *listHead, bool onBackgroundThread);
 
     void wipeDuringParallelExecution(JSRuntime *rt);
 
   private:
--- a/js/src/jsinfer.cpp
+++ b/js/src/jsinfer.cpp
@@ -16,22 +16,20 @@
 #include "jshashutil.h"
 #include "jsobj.h"
 #include "jsprf.h"
 #include "jsscript.h"
 #include "jsstr.h"
 #include "prmjtime.h"
 
 #include "gc/Marking.h"
-#ifdef JS_ION
 #include "jit/BaselineJIT.h"
 #include "jit/Ion.h"
 #include "jit/IonAnalysis.h"
 #include "jit/JitCompartment.h"
-#endif
 #include "js/MemoryMetrics.h"
 #include "vm/HelperThreads.h"
 #include "vm/Opcodes.h"
 #include "vm/Shape.h"
 
 #include "jsatominlines.h"
 #include "jsgcinlines.h"
 #include "jsobjinlines.h"
@@ -769,119 +767,83 @@ class types::CompilerConstraintList
         TemporaryTypeSet *bytecodeTypes;
     };
 
   private:
 
     // OOM during generation of some constraint.
     bool failed_;
 
-#ifdef JS_ION
     // Allocator used for constraints.
     LifoAlloc *alloc_;
 
     // Constraints generated on heap properties.
     Vector<CompilerConstraint *, 0, jit::IonAllocPolicy> constraints;
 
     // Scripts whose stack type sets were frozen for the compilation.
     Vector<FrozenScript, 1, jit::IonAllocPolicy> frozenScripts;
-#endif
 
   public:
     explicit CompilerConstraintList(jit::TempAllocator &alloc)
-      : failed_(false)
-#ifdef JS_ION
-      , alloc_(alloc.lifoAlloc())
-      , constraints(alloc)
-      , frozenScripts(alloc)
-#endif
+      : failed_(false),
+        alloc_(alloc.lifoAlloc()),
+        constraints(alloc),
+        frozenScripts(alloc)
     {}
 
     void add(CompilerConstraint *constraint) {
-#ifdef JS_ION
         if (!constraint || !constraints.append(constraint))
             setFailed();
-#else
-        MOZ_CRASH();
-#endif
     }
 
     void freezeScript(JSScript *script,
                       TemporaryTypeSet *thisTypes,
                       TemporaryTypeSet *argTypes,
                       TemporaryTypeSet *bytecodeTypes)
     {
-#ifdef JS_ION
         FrozenScript entry;
         entry.script = script;
         entry.thisTypes = thisTypes;
         entry.argTypes = argTypes;
         entry.bytecodeTypes = bytecodeTypes;
         if (!frozenScripts.append(entry))
             setFailed();
-#else
-        MOZ_CRASH();
-#endif
     }
 
     size_t length() {
-#ifdef JS_ION
         return constraints.length();
-#else
-        MOZ_CRASH();
-#endif
     }
 
     CompilerConstraint *get(size_t i) {
-#ifdef JS_ION
         return constraints[i];
-#else
-        MOZ_CRASH();
-#endif
     }
 
     size_t numFrozenScripts() {
-#ifdef JS_ION
         return frozenScripts.length();
-#else
-        MOZ_CRASH();
-#endif
     }
 
     const FrozenScript &frozenScript(size_t i) {
-#ifdef JS_ION
         return frozenScripts[i];
-#else
-        MOZ_CRASH();
-#endif
     }
 
     bool failed() {
         return failed_;
     }
     void setFailed() {
         failed_ = true;
     }
     LifoAlloc *alloc() const {
-#ifdef JS_ION
         return alloc_;
-#else
-        MOZ_CRASH();
-#endif
     }
 };
 
 CompilerConstraintList *
 types::NewCompilerConstraintList(jit::TempAllocator &alloc)
 {
-#ifdef JS_ION
     return alloc.lifoAlloc()->new_<CompilerConstraintList>(alloc);
-#else
-    MOZ_CRASH();
-#endif
 }
 
 /* static */ bool
 TypeScript::FreezeTypeSets(CompilerConstraintList *constraints, JSScript *script,
                            TemporaryTypeSet **pThisTypes,
                            TemporaryTypeSet **pArgTypes,
                            TemporaryTypeSet **pBytecodeTypes)
 {
@@ -1054,28 +1016,26 @@ TypeObjectKey::property(jsid id)
         property.maybeTypes_ = type->maybeGetProperty(id);
 
     return property;
 }
 
 void
 TypeObjectKey::ensureTrackedProperty(JSContext *cx, jsid id)
 {
-#ifdef JS_ION
     // If we are accessing a lazily defined property which actually exists in
     // the VM and has not been instantiated yet, instantiate it now if we are
     // on the main thread and able to do so.
     if (!JSID_IS_VOID(id) && !JSID_IS_EMPTY(id)) {
         JS_ASSERT(CurrentThreadCanAccessRuntime(cx->runtime()));
         if (JSObject *obj = singleton()) {
             if (obj->isNative() && obj->nativeLookupPure(id))
                 EnsureTrackPropertyTypes(cx, obj, id);
         }
     }
-#endif // JS_ION
 }
 
 bool
 HeapTypeSetKey::instantiate(JSContext *cx)
 {
     if (maybeTypes())
         return true;
     if (object()->isSingleObject() && !object()->asSingleObject()->getType(cx)) {
@@ -2283,19 +2243,17 @@ TypeZone::processPendingRecompiles(FreeO
         return;
 
     /* Steal the list of scripts to recompile, else we will try to recursively recompile them. */
     Vector<RecompileInfo> *pending = pendingRecompiles;
     pendingRecompiles = nullptr;
 
     JS_ASSERT(!pending->empty());
 
-#ifdef JS_ION
     jit::Invalidate(*this, fop, *pending);
-#endif
 
     fop->delete_(pending);
 }
 
 void
 TypeZone::addPendingRecompile(JSContext *cx, const RecompileInfo &info)
 {
     CompilerOutput *co = info.compilerOutput(cx);
@@ -2317,29 +2275,27 @@ TypeZone::addPendingRecompile(JSContext 
         CrashAtUnhandlableOOM("Could not update pendingRecompiles");
 }
 
 void
 TypeZone::addPendingRecompile(JSContext *cx, JSScript *script)
 {
     JS_ASSERT(script);
 
-#ifdef JS_ION
     CancelOffThreadIonCompile(cx->compartment(), script);
 
     // Let the script warm up again before attempting another compile.
     if (jit::IsBaselineEnabled(cx))
         script->resetUseCount();
 
     if (script->hasIonScript())
         addPendingRecompile(cx, script->ionScript()->recompileInfo());
 
     if (script->hasParallelIonScript())
         addPendingRecompile(cx, script->parallelIonScript()->recompileInfo());
-#endif
 
     // When one script is inlined into another the caller listens to state
     // changes on the callee's script, so trigger these to force recompilation
     // of any such callers.
     if (script->functionNonDelazifying() && !script->functionNonDelazifying()->hasLazyType())
         ObjectStateChange(cx, script->functionNonDelazifying()->type(), false);
 }
 
@@ -3426,17 +3382,16 @@ types::AddClearDefiniteFunctionUsesInScr
  * by the specified script, or regenerate the constraints for an existing
  * newScript on the type after they were cleared by a GC.
  */
 static void
 CheckNewScriptProperties(JSContext *cx, TypeObject *type, JSFunction *fun)
 {
     JS_ASSERT(cx->compartment()->activeAnalysis);
 
-#ifdef JS_ION
     if (type->unknownProperties())
         return;
 
     /* Strawman object to add properties to and watch for duplicates. */
     RootedObject baseobj(cx, NewBuiltinClassInstance(cx, &JSObject::class_, gc::FINALIZE_OBJECT16));
     if (!baseobj)
         return;
 
@@ -3501,17 +3456,16 @@ CheckNewScriptProperties(JSContext *cx, 
 
     newScript->initializerList = (TypeNewScript::Initializer *)
         ((char *) newScript + sizeof(TypeNewScript));
     PodCopy(newScript->initializerList,
             initializerList.begin(),
             initializerList.length());
 
     js::gc::TraceTypeNewScript(type);
-#endif // JS_ION
 }
 
 /////////////////////////////////////////////////////////////////////
 // Interface functions
 /////////////////////////////////////////////////////////////////////
 
 void
 types::TypeMonitorCallSlow(JSContext *cx, JSObject *callee, const CallArgs &args,
@@ -4341,22 +4295,20 @@ TypeScript::destroy()
 }
 
 void
 Zone::addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf,
                              size_t *typePool,
                              size_t *baselineStubsOptimized)
 {
     *typePool += types.typeLifoAlloc.sizeOfExcludingThis(mallocSizeOf);
-#ifdef JS_ION
     if (jitZone()) {
         *baselineStubsOptimized +=
             jitZone()->optimizedStubSpace()->sizeOfExcludingThis(mallocSizeOf);
     }
-#endif
 }
 
 void
 TypeCompartment::addSizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf,
                                         size_t *allocationSiteTables,
                                         size_t *arrayTypeTables,
                                         size_t *objectTypeTables)
 {
@@ -4414,32 +4366,30 @@ TypeZone::sweep(FreeOp *fop, bool releas
      * sweeping types any live data will be allocated into the pool.
      */
     LifoAlloc oldAlloc(typeLifoAlloc.defaultChunkSize());
     oldAlloc.steal(&typeLifoAlloc);
 
     /* Sweep and find compressed indexes for each compiler output. */
     size_t newCompilerOutputCount = 0;
 
-#ifdef JS_ION
     if (compilerOutputs) {
         for (size_t i = 0; i < compilerOutputs->length(); i++) {
             CompilerOutput &output = (*compilerOutputs)[i];
             if (output.isValid()) {
                 JSScript *script = output.script();
                 if (IsScriptAboutToBeFinalized(&script)) {
                     jit::GetIonScript(script, output.mode())->recompileInfoRef() = RecompileInfo(uint32_t(-1));
                     output.invalidate();
                 } else {
                     output.setSweepIndex(newCompilerOutputCount++);
                 }
             }
         }
     }
-#endif
 
     {
         gcstats::AutoPhase ap2(rt->gc.stats, gcstats::PHASE_DISCARD_TI);
 
         for (ZoneCellIterUnderGC i(zone(), FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
             if (script->types) {
                 types::TypeScript::Sweep(fop, script, oom);
--- a/js/src/jsinferinlines.h
+++ b/js/src/jsinferinlines.h
@@ -30,27 +30,23 @@ namespace types {
 
 /////////////////////////////////////////////////////////////////////
 // CompilerOutput & RecompileInfo
 /////////////////////////////////////////////////////////////////////
 
 inline jit::IonScript *
 CompilerOutput::ion() const
 {
-#ifdef JS_ION
     // Note: If type constraints are generated before compilation has finished
     // (i.e. after IonBuilder but before CodeGenerator::link) then a valid
     // CompilerOutput may not yet have an associated IonScript.
     JS_ASSERT(isValid());
     jit::IonScript *ion = jit::GetIonScript(script(), mode());
     JS_ASSERT(ion != ION_COMPILING_SCRIPT);
     return ion;
-#else
-    MOZ_CRASH("Invalid kind of CompilerOutput");
-#endif
 }
 
 inline CompilerOutput*
 RecompileInfo::compilerOutput(TypeZone &types) const
 {
     if (!types.compilerOutputs || outputIndex >= types.compilerOutputs->length())
         return nullptr;
     return &(*types.compilerOutputs)[outputIndex];
@@ -658,23 +654,19 @@ TypeScript::BytecodeTypes(JSScript *scri
     *hint = mid;
     return typeArray + *hint;
 }
 
 /* static */ inline StackTypeSet *
 TypeScript::BytecodeTypes(JSScript *script, jsbytecode *pc)
 {
     JS_ASSERT(CurrentThreadCanAccessRuntime(script->runtimeFromMainThread()));
-#ifdef JS_ION
     uint32_t *hint = script->baselineScript()->bytecodeTypeMap() + script->nTypeSets();
     return BytecodeTypes(script, pc, script->baselineScript()->bytecodeTypeMap(),
                          hint, script->types->typeArray());
-#else
-    MOZ_CRASH();
-#endif
 }
 
 struct AllocationSiteKey : public DefaultHasher<AllocationSiteKey> {
     JSScript *script;
 
     uint32_t offset : 24;
     JSProtoKey kind : 8;
 
--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -4583,29 +4583,27 @@ NativeGetInline(JSContext *cx,
         vp.setUndefined();
     }
     if (shape->hasDefaultGetter())
         return true;
 
     {
         jsbytecode *pc;
         JSScript *script = cx->currentScript(&pc);
-#ifdef JS_ION
         if (script && script->hasBaselineScript()) {
             switch (JSOp(*pc)) {
               case JSOP_GETPROP:
               case JSOP_CALLPROP:
               case JSOP_LENGTH:
                 script->baselineScript()->noteAccessedGetter(script->pcToOffset(pc));
                 break;
               default:
                 break;
             }
         }
-#endif
     }
 
     if (!allowGC)
         return false;
 
     if (!shape->get(cx,
                     MaybeRooted<JSObject*, allowGC>::toHandle(receiver),
                     MaybeRooted<JSObject*, allowGC>::toHandle(obj),
@@ -6160,21 +6158,19 @@ JSObject::addSizeOfExcludingThis(mozilla
     } else if (is<ArgumentsObject>()) {
         sizes->mallocHeapArgumentsData += as<ArgumentsObject>().sizeOfMisc(mallocSizeOf);
     } else if (is<RegExpStaticsObject>()) {
         sizes->mallocHeapRegExpStatics += as<RegExpStaticsObject>().sizeOfData(mallocSizeOf);
     } else if (is<PropertyIteratorObject>()) {
         sizes->mallocHeapPropertyIteratorData += as<PropertyIteratorObject>().sizeOfMisc(mallocSizeOf);
     } else if (is<ArrayBufferObject>() || is<SharedArrayBufferObject>()) {
         ArrayBufferObject::addSizeOfExcludingThis(this, mallocSizeOf, sizes);
-#ifdef JS_ION
     } else if (is<AsmJSModuleObject>()) {
         as<AsmJSModuleObject>().addSizeOfMisc(mallocSizeOf, &sizes->nonHeapCodeAsmJS,
                                               &sizes->mallocHeapAsmJSModuleData);
-#endif
 #ifdef JS_HAS_CTYPES
     } else {
         // This must be the last case.
         sizes->mallocHeapCtypesData +=
             js::SizeOfDataIfCDataObject(mallocSizeOf, const_cast<JSObject *>(this));
 #endif
     }
 }
--- a/js/src/jsopcode.cpp
+++ b/js/src/jsopcode.cpp
@@ -213,33 +213,31 @@ PCCounts::countName(JSOp op, size_t whic
     }
 
     if (arithOp(op))
         return countArithNames[which - BASE_LIMIT];
 
     MOZ_CRASH("bad op");
 }
 
-#ifdef JS_ION
 void
 js::DumpIonScriptCounts(Sprinter *sp, jit::IonScriptCounts *ionCounts)
 {
     Sprint(sp, "IonScript [%lu blocks]:\n", ionCounts->numBlocks());
     for (size_t i = 0; i < ionCounts->numBlocks(); i++) {
         const jit::IonBlockCounts &block = ionCounts->block(i);
         if (block.hitCount() < 10)
             continue;
         Sprint(sp, "BB #%lu [%05u]", block.id(), block.offset());
         for (size_t j = 0; j < block.numSuccessors(); j++)
             Sprint(sp, " -> #%lu", block.successor(j));
         Sprint(sp, " :: %llu hits\n", block.hitCount());
         Sprint(sp, "%s\n", block.code());
     }
 }
-#endif
 
 void
 js_DumpPCCounts(JSContext *cx, HandleScript script, js::Sprinter *sp)
 {
     JS_ASSERT(script->hasScriptCounts());
 
 #ifdef DEBUG
     jsbytecode *pc = script->code();
@@ -265,24 +263,22 @@ js_DumpPCCounts(JSContext *cx, HandleScr
             }
         }
         Sprint(sp, "}\n");
 
         pc = next;
     }
 #endif
 
-#ifdef JS_ION
     jit::IonScriptCounts *ionCounts = script->getIonCounts();
 
     while (ionCounts) {
         DumpIonScriptCounts(sp, ionCounts);
         ionCounts = ionCounts->previous();
     }
-#endif
 }
 
 /////////////////////////////////////////////////////////////////////
 // Bytecode Parser
 /////////////////////////////////////////////////////////////////////
 
 namespace {
 
--- a/js/src/jsopcode.h
+++ b/js/src/jsopcode.h
@@ -830,17 +830,15 @@ unsigned
 js_Disassemble1(JSContext *cx, JS::Handle<JSScript*> script, jsbytecode *pc, unsigned loc,
                 bool lines, js::Sprinter *sp);
 
 #endif
 
 void
 js_DumpPCCounts(JSContext *cx, JS::Handle<JSScript*> script, js::Sprinter *sp);
 
-#ifdef JS_ION
 namespace js {
 namespace jit { struct IonScriptCounts; }
 void
 DumpIonScriptCounts(js::Sprinter *sp, jit::IonScriptCounts *ionCounts);
 }
-#endif
 
 #endif /* jsopcode_h */
--- a/js/src/jsscript.cpp
+++ b/js/src/jsscript.cpp
@@ -2620,19 +2620,17 @@ JSScript::finalize(FreeOp *fop)
     // JSScript::Create(), but not yet finished initializing it with
     // fullyInitFromEmitter() or fullyInitTrivial().
 
     fop->runtime()->spsProfiler.onScriptFinalized(this);
 
     if (types)
         types->destroy();
 
-#ifdef JS_ION
     jit::DestroyIonScripts(fop, this);
-#endif
 
     destroyScriptCounts(fop);
     destroyDebugScript(fop);
 
     if (data) {
         JS_POISON(data, 0xdb, computedSizeOfData());
         fop->free_(data);
     }
@@ -3192,20 +3190,18 @@ JSScript::ensureHasDebugScript(JSContext
 void
 JSScript::setNewStepMode(FreeOp *fop, uint32_t newValue)
 {
     DebugScript *debug = debugScript();
     uint32_t prior = debug->stepMode;
     debug->stepMode = newValue;
 
     if (!prior != !newValue) {
-#ifdef JS_ION
         if (hasBaselineScript())
             baseline->toggleDebugTraps(this, nullptr);
-#endif
 
         if (!stepModeEnabled() && !debug->numSites)
             fop->free_(releaseDebugScript());
     }
 }
 
 bool
 JSScript::setStepModeFlag(JSContext *cx, bool step)
@@ -3363,19 +3359,17 @@ JSScript::markChildren(JSTracer *trc)
         compartment()->mark();
 
         if (code())
             MarkScriptData(trc->runtime(), code());
     }
 
     bindings.trace(trc);
 
-#ifdef JS_ION
     jit::TraceIonScripts(trc, this);
-#endif
 }
 
 void
 LazyScript::markChildren(JSTracer *trc)
 {
     if (function_)
         MarkObject(trc, &function_, "function");
 
@@ -3458,22 +3452,17 @@ JSScript::getStaticScope(jsbytecode *pc)
 
     return blockChain;
 }
 
 void
 JSScript::setArgumentsHasVarBinding()
 {
     argsHasVarBinding_ = true;
-#ifdef JS_ION
     needsArgsAnalysis_ = true;
-#else
-    // The arguments analysis is performed by IonBuilder.
-    needsArgsObj_ = true;
-#endif
 }
 
 void
 JSScript::setNeedsArgsObj(bool needsArgsObj)
 {
     JS_ASSERT_IF(needsArgsObj, argumentsHasVarBinding());
     needsArgsAnalysis_ = false;
     needsArgsObj_ = needsArgsObj;
@@ -3529,25 +3518,23 @@ JSScript::argumentsOptimizationFailed(JS
      */
     if (script->needsArgsObj())
         return true;
 
     JS_ASSERT(!script->isGenerator());
 
     script->needsArgsObj_ = true;
 
-#ifdef JS_ION
     /*
      * Since we can't invalidate baseline scripts, set a flag that's checked from
      * JIT code to indicate the arguments optimization failed and JSOP_ARGUMENTS
      * should create an arguments object next time.
      */
     if (script->hasBaselineScript())
         script->baselineScript()->setNeedsArgsObj();
-#endif
 
     /*
      * By design, the arguments optimization is only made when there are no
      * outstanding cases of MagicValue(JS_OPTIMIZED_ARGUMENTS) at any points
      * where the optimization could fail, other than an active invocation of
      * 'f.apply(x, arguments)'. Thus, there are no outstanding values of
      * MagicValue(JS_OPTIMIZED_ARGUMENTS) on the stack. However, there are
      * three things that need fixup:
@@ -3777,28 +3764,26 @@ LazyScript::staticLevel(JSContext *cx) c
             return ssi.funScript()->staticLevel() + 1;
     }
     return 1;
 }
 
 void
 JSScript::updateBaselineOrIonRaw()
 {
-#ifdef JS_ION
     if (hasIonScript()) {
         baselineOrIonRaw = ion->method()->raw();
         baselineOrIonSkipArgCheck = ion->method()->raw() + ion->getSkipArgCheckEntryOffset();
     } else if (hasBaselineScript()) {
         baselineOrIonRaw = baseline->method()->raw();
         baselineOrIonSkipArgCheck = baseline->method()->raw();
     } else {
         baselineOrIonRaw = nullptr;
         baselineOrIonSkipArgCheck = nullptr;
     }
-#endif
 }
 
 bool
 JSScript::hasLoops()
 {
     if (!hasTrynotes())
         return false;
     JSTryNote *tn = trynotes()->vector;
--- a/js/src/jsscriptinlines.h
+++ b/js/src/jsscriptinlines.h
@@ -160,30 +160,24 @@ JSScript::setIsCallsiteClone(JSObject *f
     JS_ASSERT(isCallsiteClone());
     JS_ASSERT(fun->is<JSFunction>());
     enclosingScopeOrOriginalFunction_ = fun;
 }
 
 inline void
 JSScript::setBaselineScript(JSContext *maybecx, js::jit::BaselineScript *baselineScript)
 {
-#ifdef JS_ION
     if (hasBaselineScript())
         js::jit::BaselineScript::writeBarrierPre(tenuredZone(), baseline);
-#endif
     MOZ_ASSERT(!hasIonScript());
     baseline = baselineScript;
     updateBaselineOrIonRaw();
 }
 
 inline bool
 JSScript::ensureHasAnalyzedArgsUsage(JSContext *cx)
 {
     if (analyzedArgsUsage())
         return true;
-#ifdef JS_ION
     return js::jit::AnalyzeArgumentsUsage(cx, this);
-#else
-    MOZ_CRASH();
-#endif
 }
 
 #endif /* jsscriptinlines_h */
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -3849,17 +3849,17 @@ EscapeForShell(AutoCStringVector &argv)
         argv.replace(i, escaped);
     }
     return true;
 }
 #endif
 
 static Vector<const char*, 4, js::SystemAllocPolicy> sPropagatedFlags;
 
-#if defined(DEBUG) && defined(JS_ION) && (defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64))
+#if defined(DEBUG) && (defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64))
 static bool
 PropagateFlagToNestedShells(const char *flag)
 {
     return sPropagatedFlags.append(flag);
 }
 #endif
 
 static bool
@@ -5657,27 +5657,22 @@ BindScriptArgs(JSContext *cx, JSObject *
         {
             return false;
         }
     }
 
     return true;
 }
 
-// This function is currently only called from "#if defined(JS_ION)" chunks,
-// so we're guarding the function definition with an #ifdef, too, to avoid
-// build warning for unused function in non-ion-enabled builds:
-#if defined(JS_ION)
 static bool
 OptionFailure(const char *option, const char *str)
 {
     fprintf(stderr, "Unrecognized option for %s: %s\n", option, str);
     return false;
 }
-#endif /* JS_ION */
 
 static int
 ProcessArgs(JSContext *cx, JSObject *obj_, OptionParser *op)
 {
     RootedObject obj(cx, obj_);
 
     if (op->getBoolOption('s'))
         JS::ContextOptionsRef(cx).toggleExtraWarnings();
@@ -5728,17 +5723,16 @@ ProcessArgs(JSContext *cx, JSObject *obj
         Process(cx, obj, nullptr, true);
 
     return gExitCode ? gExitCode : EXIT_SUCCESS;
 }
 
 static bool
 SetRuntimeOptions(JSRuntime *rt, const OptionParser &op)
 {
-#if defined(JS_ION)
     bool enableBaseline = !op.getBoolOption("no-baseline");
     bool enableIon = !op.getBoolOption("no-ion");
     bool enableAsmJS = !op.getBoolOption("no-asmjs");
     bool enableNativeRegExp = !op.getBoolOption("no-native-regexp");
 
     JS::RuntimeOptionsRef(rt).setBaseline(enableBaseline)
                              .setIon(enableIon)
                              .setAsmJS(enableAsmJS)
@@ -5864,18 +5858,16 @@ SetRuntimeOptions(JSRuntime *rt, const O
     }
     rt->setOffthreadIonCompilationEnabled(offthreadCompilation);
 
     if (op.getStringOption("ion-parallel-compile")) {
         fprintf(stderr, "--ion-parallel-compile is deprecated. Please use --ion-offthread-compile instead.\n");
         return false;
     }
 
-#endif // JS_ION
-
 #if defined(JS_CODEGEN_ARM)
     if (const char *str = op.getStringOption("arm-hwcap"))
         jit::ParseARMHwCapFlags(str);
 
     int32_t fill = op.getIntOption("arm-asm-nop-fill");
     if (fill >= 0)
         jit::Assembler::NopFill = fill;
 
@@ -6152,22 +6144,22 @@ main(int argc, char **argv, char **envp)
 
 #ifdef DEBUG
     /*
      * Process OOM options as early as possible so that we can observe as many
      * allocations as possible.
      */
     OOM_printAllocationCount = op.getBoolOption('O');
 
-#if defined(JS_CODEGEN_X86) && defined(JS_ION)
+#ifdef JS_CODEGEN_X86
     if (op.getBoolOption("no-fpu"))
         JSC::MacroAssembler::SetFloatingPointDisabled();
 #endif
 
-#if (defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)) && defined(JS_ION)
+#if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
     if (op.getBoolOption("no-sse3")) {
         JSC::MacroAssembler::SetSSE3Disabled();
         PropagateFlagToNestedShells("--no-sse3");
     }
     if (op.getBoolOption("no-sse4")) {
         JSC::MacroAssembler::SetSSE4Disabled();
         PropagateFlagToNestedShells("--no-sse4");
     }
--- a/js/src/vm/ArgumentsObject.cpp
+++ b/js/src/vm/ArgumentsObject.cpp
@@ -3,19 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "vm/ArgumentsObject-inl.h"
 
 #include "jsinfer.h"
 
-#ifdef JS_ION
 #include "jit/IonFrames.h"
-#endif
 #include "vm/GlobalObject.h"
 #include "vm/Stack.h"
 
 #include "jsobjinlines.h"
 
 #include "vm/Stack-inl.h"
 
 using namespace js;
@@ -42,31 +40,29 @@ ArgumentsObject::MaybeForwardToCallObjec
     JSScript *script = frame.script();
     if (frame.fun()->isHeavyweight() && script->argsObjAliasesFormals()) {
         obj->initFixedSlot(MAYBE_CALL_SLOT, ObjectValue(frame.callObj()));
         for (AliasedFormalIter fi(script); fi; fi++)
             data->args[fi.frameIndex()] = JS::MagicValueUint32(fi.scopeSlot());
     }
 }
 
-#if defined(JS_ION)
 /* static */ void
 ArgumentsObject::MaybeForwardToCallObject(jit::IonJSFrameLayout *frame, HandleObject callObj,
                                           JSObject *obj, ArgumentsData *data)
 {
     JSFunction *callee = jit::CalleeTokenToFunction(frame->calleeToken());
     JSScript *script = callee->nonLazyScript();
     if (callee->isHeavyweight() && script->argsObjAliasesFormals()) {
         JS_ASSERT(callObj && callObj->is<CallObject>());
         obj->initFixedSlot(MAYBE_CALL_SLOT, ObjectValue(*callObj.get()));
         for (AliasedFormalIter fi(script); fi; fi++)
             data->args[fi.frameIndex()] = JS::MagicValueUint32(fi.scopeSlot());
     }
 }
-#endif
 
 struct CopyFrameArgs
 {
     AbstractFramePtr frame_;
 
     explicit CopyFrameArgs(AbstractFramePtr frame)
       : frame_(frame)
     { }
@@ -79,17 +75,16 @@ struct CopyFrameArgs
      * If a call object exists and the arguments object aliases formals, the
      * call object is the canonical location for formals.
      */
     void maybeForwardToCallObject(JSObject *obj, ArgumentsData *data) {
         ArgumentsObject::MaybeForwardToCallObject(frame_, obj, data);
     }
 };
 
-#if defined(JS_ION)
 struct CopyIonJSFrameArgs
 {
     jit::IonJSFrameLayout *frame_;
     HandleObject callObj_;
 
     CopyIonJSFrameArgs(jit::IonJSFrameLayout *frame, HandleObject callObj)
       : frame_(frame), callObj_(callObj)
     { }
@@ -118,17 +113,16 @@ struct CopyIonJSFrameArgs
     /*
      * If a call object exists and the arguments object aliases formals, the
      * call object is the canonical location for formals.
      */
     void maybeForwardToCallObject(JSObject *obj, ArgumentsData *data) {
         ArgumentsObject::MaybeForwardToCallObject(frame_, callObj_, obj, data);
     }
 };
-#endif
 
 struct CopyScriptFrameIterArgs
 {
     ScriptFrameIter &iter_;
 
     explicit CopyScriptFrameIterArgs(ScriptFrameIter &iter)
       : iter_(iter)
     { }
@@ -255,29 +249,27 @@ ArgumentsObject *
 ArgumentsObject::createUnexpected(JSContext *cx, AbstractFramePtr frame)
 {
     RootedScript script(cx, frame.script());
     RootedFunction callee(cx, frame.callee());
     CopyFrameArgs copy(frame);
     return create(cx, script, callee, frame.numActualArgs(), copy);
 }
 
-#if defined(JS_ION)
 ArgumentsObject *
 ArgumentsObject::createForIon(JSContext *cx, jit::IonJSFrameLayout *frame, HandleObject scopeChain)
 {
     jit::CalleeToken token = frame->calleeToken();
     JS_ASSERT(jit::CalleeTokenIsFunction(token));
     RootedScript script(cx, jit::ScriptFromCalleeToken(token));
     RootedFunction callee(cx, jit::CalleeTokenToFunction(token));
     RootedObject callObj(cx, scopeChain->is<CallObject>() ? scopeChain.get() : nullptr);
     CopyIonJSFrameArgs copy(frame, callObj);
     return create(cx, script, callee, frame->numActualArgs(), copy);
 }
-#endif
 
 static bool
 args_delProperty(JSContext *cx, HandleObject obj, HandleId id, bool *succeeded)
 {
     ArgumentsObject &argsobj = obj->as<ArgumentsObject>();
     if (JSID_IS_INT(id)) {
         unsigned arg = unsigned(JSID_TO_INT(id));
         if (arg < argsobj.initialLength() && !argsobj.isElementDeleted(arg))
--- a/js/src/vm/ArgumentsObject.h
+++ b/js/src/vm/ArgumentsObject.h
@@ -138,20 +138,18 @@ class ArgumentsObject : public JSObject
     /*
      * Purposefully disconnect the returned arguments object from the frame
      * by always creating a new copy that does not alias formal parameters.
      * This allows function-local analysis to determine that formals are
      * not aliased and generally simplifies arguments objects.
      */
     static ArgumentsObject *createUnexpected(JSContext *cx, ScriptFrameIter &iter);
     static ArgumentsObject *createUnexpected(JSContext *cx, AbstractFramePtr frame);
-#if defined(JS_ION)
     static ArgumentsObject *createForIon(JSContext *cx, jit::IonJSFrameLayout *frame,
                                          HandleObject scopeChain);
-#endif
 
     /*
      * Return the initial length of the arguments.  This may differ from the
      * current value of arguments.length!
      */
     uint32_t initialLength() const {
         uint32_t argc = uint32_t(getFixedSlot(INITIAL_LENGTH_SLOT).toInt32()) >> PACKED_BITS_COUNT;
         JS_ASSERT(argc <= ARGS_LENGTH_MAX);
@@ -269,20 +267,18 @@ class ArgumentsObject : public JSObject
     static size_t getDataSlotOffset() {
         return getFixedSlotOffset(DATA_SLOT);
     }
     static size_t getInitialLengthSlotOffset() {
         return getFixedSlotOffset(INITIAL_LENGTH_SLOT);
     }
 
     static void MaybeForwardToCallObject(AbstractFramePtr frame, JSObject *obj, ArgumentsData *data);
-#if defined(JS_ION)
     static void MaybeForwardToCallObject(jit::IonJSFrameLayout *frame, HandleObject callObj,
                                          JSObject *obj, ArgumentsData *data);
-#endif
 };
 
 class NormalArgumentsObject : public ArgumentsObject
 {
   public:
     static const Class class_;
 
     /*
--- a/js/src/vm/ArrayBufferObject.cpp
+++ b/js/src/vm/ArrayBufferObject.cpp
@@ -542,29 +542,25 @@ ArrayBufferObject::releaseAsmJSArray(Fre
     releaseAsmJSArrayNoSignals(fop);
 }
 #endif
 
 bool
 ArrayBufferObject::canNeuterAsmJSArrayBuffer(JSContext *cx, ArrayBufferObject &buffer)
 {
     JS_ASSERT(!buffer.isSharedArrayBuffer());
-#ifdef JS_ION
     AsmJSActivation *act = cx->mainThread().asmJSActivationStack();
     for (; act; act = act->prevAsmJS()) {
         if (act->module().maybeHeapBufferObject() == &buffer)
             break;
     }
     if (!act)
         return true;
 
     return false;
-#else
-    return true;
-#endif
 }
 
 void *
 ArrayBufferObject::createMappedContents(int fd, size_t offset, size_t length)
 {
     return AllocateMappedContent(fd, offset, length, ARRAY_BUFFER_ALIGNMENT);
 }
 
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -239,20 +239,18 @@ BreakpointSite::BreakpointSite(JSScript 
 {
     JS_ASSERT(!script->hasBreakpointsAt(pc));
     JS_INIT_CLIST(&breakpoints);
 }
 
 void
 BreakpointSite::recompile(FreeOp *fop)
 {
-#ifdef JS_ION
     if (script->hasBaselineScript())
         script->baselineScript()->toggleDebugTraps(script, pc);
-#endif
 }
 
 void
 BreakpointSite::inc(FreeOp *fop)
 {
     enabledCount++;
     if (enabledCount == 1)
         recompile(fop);
@@ -4161,17 +4159,17 @@ static const JSFunctionSpec DebuggerSour
 
 
 /*** Debugger.Frame ******************************************************************************/
 
 static void
 UpdateFrameIterPc(FrameIter &iter)
 {
     if (iter.abstractFramePtr().isRematerializedFrame()) {
-#if defined(DEBUG) && defined(JS_ION)
+#ifdef DEBUG
         // Rematerialized frames don't need their pc updated. The reason we
         // need to update pc is because we might get the same Debugger.Frame
         // object for multiple re-entries into debugger code from debuggee
         // code. This reentrancy is not possible with rematerialized frames,
         // because when returning to debuggee code, we would have bailed out
         // to baseline.
         //
         // We walk the stack to assert that it doesn't need updating.
--- a/js/src/vm/ForkJoin.cpp
+++ b/js/src/vm/ForkJoin.cpp
@@ -15,42 +15,39 @@
 #include "mozilla/ThreadLocal.h"
 
 #include "jscntxt.h"
 #include "jslock.h"
 #include "jsprf.h"
 
 #include "builtin/TypedObject.h"
 #include "jit/BaselineJIT.h"
+#include "jit/JitCommon.h"
+#include "jit/RematerializedFrame.h"
+#ifdef FORKJOIN_SPEW
+# include "jit/Ion.h"
+# include "jit/JitCompartment.h"
+# include "jit/MIR.h"
+# include "jit/MIRGraph.h"
+#endif
 #include "vm/Monitor.h"
 
-#ifdef JS_ION
-# include "jit/JitCommon.h"
-# include "jit/RematerializedFrame.h"
-# ifdef FORKJOIN_SPEW
-#  include "jit/Ion.h"
-#  include "jit/JitCompartment.h"
-#  include "jit/MIR.h"
-#  include "jit/MIRGraph.h"
-# endif
-#endif // JS_ION
-
 #include "gc/ForkJoinNursery-inl.h"
 #include "vm/Interpreter-inl.h"
 
 using namespace js;
 using namespace js::parallel;
 using namespace js::jit;
 
 using mozilla::ThreadLocal;
 
 ///////////////////////////////////////////////////////////////////////////
 // Degenerate configurations
 //
-// When JS_ION is not defined, we simply run the |func| callback
+// When IonMonkey is disabled, we simply run the |func| callback
 // sequentially.  We also forego the feedback altogether.
 
 static bool
 ExecuteSequentially(JSContext *cx_, HandleValue funVal, uint16_t *sliceStart,
                     uint16_t sliceEnd);
 
 static bool
 ForkJoinSequentially(JSContext *cx, CallArgs &args)
@@ -59,126 +56,16 @@ ForkJoinSequentially(JSContext *cx, Call
     uint16_t sliceStart = uint16_t(args[1].toInt32());
     uint16_t sliceEnd = uint16_t(args[2].toInt32());
     if (!ExecuteSequentially(cx, argZero, &sliceStart, sliceEnd))
         return false;
     MOZ_ASSERT(sliceStart == sliceEnd);
     return true;
 }
 
-#if !defined(JS_ION)
-bool
-js::ForkJoin(JSContext *cx, CallArgs &args)
-{
-    return ForkJoinSequentially(cx, args);
-}
-
-JSContext *
-ForkJoinContext::acquireJSContext()
-{
-    return nullptr;
-}
-
-void
-ForkJoinContext::releaseJSContext()
-{
-}
-
-bool
-ForkJoinContext::isMainThread() const
-{
-    return true;
-}
-
-JSRuntime *
-ForkJoinContext::runtime()
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-bool
-ForkJoinContext::check()
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-void
-ForkJoinContext::requestGC(JS::gcreason::Reason reason)
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-void
-ForkJoinContext::requestZoneGC(JS::Zone *zone, JS::gcreason::Reason reason)
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-bool
-ForkJoinContext::setPendingAbortFatal(ParallelBailoutCause cause)
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-void
-ParallelBailoutRecord::rematerializeFrames(ForkJoinContext *cx, JitFrameIterator &frameIter)
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-void
-ParallelBailoutRecord::rematerializeFrames(ForkJoinContext *cx, IonBailoutIterator &frameIter)
-{
-    MOZ_CRASH("Not THREADSAFE build");
-}
-
-bool
-js::InExclusiveParallelSection()
-{
-    return false;
-}
-
-bool
-js::ParallelTestsShouldPass(JSContext *cx)
-{
-    return false;
-}
-
-bool
-js::intrinsic_SetForkJoinTargetRegion(JSContext *cx, unsigned argc, Value *vp)
-{
-    return true;
-}
-
-static bool
-intrinsic_SetForkJoinTargetRegionPar(ForkJoinContext *cx, unsigned argc, Value *vp)
-{
-    return true;
-}
-
-JS_JITINFO_NATIVE_PARALLEL(js::intrinsic_SetForkJoinTargetRegionInfo,
-                           intrinsic_SetForkJoinTargetRegionPar);
-
-bool
-js::intrinsic_ClearThreadLocalArenas(JSContext *cx, unsigned argc, Value *vp)
-{
-    return true;
-}
-
-static bool
-intrinsic_ClearThreadLocalArenasPar(ForkJoinContext *cx, unsigned argc, Value *vp)
-{
-    return true;
-}
-
-JS_JITINFO_NATIVE_PARALLEL(js::intrinsic_ClearThreadLocalArenasInfo,
-                           intrinsic_ClearThreadLocalArenasPar);
-
-#endif // !JS_ION
-
 ///////////////////////////////////////////////////////////////////////////
 // All configurations
 //
 // Some code that is shared between degenerate and parallel configurations.
 
 static bool
 ExecuteSequentially(JSContext *cx, HandleValue funVal, uint16_t *sliceStart,
                     uint16_t sliceEnd)
@@ -208,20 +95,17 @@ ForkJoinContext::initializeTls()
             return false;
     }
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Parallel configurations
 //
-// The remainder of this file is specific to cases where
-// JS_ION is enabled.
-
-#ifdef JS_ION
+// The remainder of this file is specific to cases where IonMonkey is enabled.
 
 ///////////////////////////////////////////////////////////////////////////
 // Class Declarations and Function Prototypes
 
 namespace js {
 
 // When writing tests, it is often useful to specify different modes
 // of operation.
@@ -2462,10 +2346,8 @@ static bool
 intrinsic_ClearThreadLocalArenasPar(ForkJoinContext *cx, unsigned argc, Value *vp)
 {
     cx->allocator()->arenas.wipeDuringParallelExecution(cx->runtime());
     return true;
 }
 
 JS_JITINFO_NATIVE_PARALLEL(js::intrinsic_ClearThreadLocalArenasInfo,
                            intrinsic_ClearThreadLocalArenasPar);
-
-#endif // JS_ION
--- a/js/src/vm/ForkJoin.h
+++ b/js/src/vm/ForkJoin.h
@@ -518,35 +518,27 @@ class ForkJoinContext : public ThreadSaf
 // that want to access that data will also acquire the lock, which is
 // generally not the case. For example, the lock is used in the IC
 // code to allow us to atomically patch up the dispatch table, but we
 // must be aware that other threads may be reading from the table even
 // as we write to it (though they cannot be writing, since they must
 // hold the lock to write).
 class LockedJSContext
 {
-#ifdef JS_ION
     ForkJoinContext *cx_;
-#endif
     JSContext *jscx_;
 
   public:
     explicit LockedJSContext(ForkJoinContext *cx)
-#ifdef JS_ION
       : cx_(cx),
         jscx_(cx->acquireJSContext())
-#else
-      : jscx_(nullptr)
-#endif
     { }
 
     ~LockedJSContext() {
-#ifdef JS_ION
         cx_->releaseJSContext();
-#endif
     }
 
     operator JSContext *() { return jscx_; }
     JSContext *operator->() { return jscx_; }
 };
 
 bool InExclusiveParallelSection();
 
@@ -586,17 +578,17 @@ enum ExecutionStatus {
 enum SpewChannel {
     SpewOps,
     SpewCompile,
     SpewBailouts,
     SpewGC,
     NumSpewChannels
 };
 
-#if defined(FORKJOIN_SPEW) && defined(JS_ION)
+#ifdef FORKJOIN_SPEW
 
 bool SpewEnabled(SpewChannel channel);
 void Spew(SpewChannel channel, const char *fmt, ...);
 void SpewVA(SpewChannel channel, const char *fmt, va_list args);
 void SpewBeginOp(JSContext *cx, const char *name);
 void SpewBailout(uint32_t count, HandleScript script, jsbytecode *pc,
                  ParallelBailoutCause cause);
 ExecutionStatus SpewEndOp(ExecutionStatus status);
@@ -609,22 +601,20 @@ void SpewMIR(jit::MDefinition *mir, cons
 static inline bool SpewEnabled(SpewChannel channel) { return false; }
 static inline void Spew(SpewChannel channel, const char *fmt, ...) { }
 static inline void SpewVA(SpewChannel channel, const char *fmt, va_list args) { }
 static inline void SpewBeginOp(JSContext *cx, const char *name) { }
 static inline void SpewBailout(uint32_t count, HandleScript script,
                                jsbytecode *pc, ParallelBailoutCause cause) {}
 static inline ExecutionStatus SpewEndOp(ExecutionStatus status) { return status; }
 static inline void SpewBeginCompile(HandleScript script) { }
-#ifdef JS_ION
 static inline jit::MethodStatus SpewEndCompile(jit::MethodStatus status) { return status; }
 static inline void SpewMIR(jit::MDefinition *mir, const char *fmt, ...) { }
-#endif
 
-#endif // FORKJOIN_SPEW && JS_ION
+#endif // FORKJOIN_SPEW
 
 } // namespace parallel
 } // namespace js
 
 /* static */ inline js::ForkJoinContext *
 js::ForkJoinContext::current()
 {
     return tlsForkJoinContext.get();
--- a/js/src/vm/HelperThreads.cpp
+++ b/js/src/vm/HelperThreads.cpp
@@ -57,18 +57,16 @@ js::SetFakeCPUCount(size_t count)
 {
     // This must be called before the threads have been initialized.
     JS_ASSERT(!HelperThreadState().threads);
 
     HelperThreadState().cpuCount = count;
     HelperThreadState().threadCount = ThreadCountForCPUCount(count);
 }
 
-#ifdef JS_ION
-
 bool
 js::StartOffThreadAsmJSCompile(ExclusiveContext *cx, AsmJSParallelTask *asmData)
 {
     // Threads already initialized by the AsmJS compiler.
     JS_ASSERT(asmData->mir);
     JS_ASSERT(asmData->lir == nullptr);
 
     AutoLockHelperThreadState lock;
@@ -104,30 +102,27 @@ js::StartOffThreadIonCompile(JSContext *
  * compilations which are started must eventually be finished.
  */
 static void
 FinishOffThreadIonCompile(jit::IonBuilder *builder)
 {
     HelperThreadState().ionFinishedList().append(builder);
 }
 
-#endif // JS_ION
-
 static inline bool
 CompiledScriptMatches(JSCompartment *compartment, JSScript *script, JSScript *target)
 {
     if (script)
         return target == script;
     return target->compartment() == compartment;
 }
 
 void
 js::CancelOffThreadIonCompile(JSCompartment *compartment, JSScript *script)
 {
-#ifdef JS_ION
     jit::JitCompartment *jitComp = compartment->jitCompartment();
     if (!jitComp)
         return;
 
     AutoLockHelperThreadState lock;
 
     if (!HelperThreadState().threads)
         return;
@@ -161,17 +156,16 @@ js::CancelOffThreadIonCompile(JSCompartm
     GlobalHelperThreadState::IonBuilderVector &finished = HelperThreadState().ionFinishedList();
     for (size_t i = 0; i < finished.length(); i++) {
         jit::IonBuilder *builder = finished[i];
         if (CompiledScriptMatches(compartment, script, builder->script())) {
             jit::FinishOffThreadBuilder(builder);
             HelperThreadState().remove(finished, &i);
         }
     }
-#endif // JS_ION
 }
 
 static const JSClass parseTaskGlobalClass = {
     "internal-parse-task-global", JSCLASS_GLOBAL_FLAGS,
     JS_PropertyStub,  JS_DeletePropertyStub,
     JS_PropertyStub,  JS_StrictPropertyStub,
     JS_EnumerateStub, JS_ResolveStub,
     JS_ConvertStub,   nullptr,
@@ -549,33 +543,29 @@ GlobalHelperThreadState::canStartAsmJSCo
         return false;
 
     return true;
 }
 
 static bool
 IonBuilderHasHigherPriority(jit::IonBuilder *first, jit::IonBuilder *second)
 {
-#ifdef JS_ION
     // This method can return whatever it wants, though it really ought to be a
     // total order. The ordering is allowed to race (change on the fly), however.
 
     // A lower optimization level indicates a higher priority.
     if (first->optimizationInfo().level() != second->optimizationInfo().level())
         return first->optimizationInfo().level() < second->optimizationInfo().level();
 
     // A script without an IonScript has precedence on one with.
     if (first->script()->hasIonScript() != second->script()->hasIonScript())
         return !first->script()->hasIonScript();
 
     // A higher useCount indicates a higher priority.
     return first->script()->getUseCount() > second->script()->getUseCount();
-#else
-    MOZ_CRASH("Cannot infer priority without Ion");
-#endif
 }
 
 bool
 GlobalHelperThreadState::canStartIonCompile()
 {
     return !ionWorklist().empty();
 }
 
@@ -838,17 +828,16 @@ HelperThread::ThreadMain(void *arg)
 #endif
 
     static_cast<HelperThread *>(arg)->threadLoop();
 }
 
 void
 HelperThread::handleAsmJSWorkload()
 {
-#ifdef JS_ION
     JS_ASSERT(HelperThreadState().isLocked());
     JS_ASSERT(HelperThreadState().canStartAsmJSCompile());
     JS_ASSERT(idle());
 
     asmData = HelperThreadState().asmJSWorklist().popCopy();
     bool success = false;
 
     do {
@@ -883,25 +872,21 @@ HelperThread::handleAsmJSWorkload()
     }
 
     // On success, move work to the finished list.
     HelperThreadState().asmJSFinishedList().append(asmData);
     asmData = nullptr;
 
     // Notify the main thread in case it's blocked waiting for a LifoAlloc.
     HelperThreadState().notifyAll(GlobalHelperThreadState::CONSUMER);
-#else
-    MOZ_CRASH();
-#endif // JS_ION
 }
 
 void
 HelperThread::handleIonWorkload()
 {
-#ifdef JS_ION
     JS_ASSERT(HelperThreadState().isLocked());
     JS_ASSERT(HelperThreadState().canStartIonCompile());
     JS_ASSERT(idle());
 
     // Find the IonBuilder in the worklist with the highest priority, and
     // remove it from the worklist.
     jit::IonBuilder *builder =
         HelperThreadState().highestPriorityPendingIonCompile(/* remove = */ true);
@@ -964,20 +949,16 @@ HelperThread::handleIonWorkload()
         if (!builder || IonBuilderHasHigherPriority(other->ionBuilder, builder)) {
             other->pause = false;
 
             // Notify all paused threads, to make sure the one we just
             // unpaused wakes up.
             HelperThreadState().notifyAll(GlobalHelperThreadState::PAUSE);
         }
     }
-
-#else
-    MOZ_CRASH();
-#endif // JS_ION
 }
 
 static HelperThread *
 CurrentHelperThread()
 {
     PRThread *prThread = PR_GetCurrentThread();
     HelperThread *thread = nullptr;
     for (size_t i = 0; i < HelperThreadState().threadCount; i++) {
--- a/js/src/vm/HelperThreads.h
+++ b/js/src/vm/HelperThreads.h
@@ -317,31 +317,27 @@ EnsureHelperThreadsInitialized(Exclusive
 // --thread-count=N option.
 void
 SetFakeCPUCount(size_t count);
 
 // Pause the current thread until it's pause flag is unset.
 void
 PauseCurrentHelperThread();
 
-#ifdef JS_ION
-
 /* Perform MIR optimization and LIR generation on a single function. */
 bool
 StartOffThreadAsmJSCompile(ExclusiveContext *cx, AsmJSParallelTask *asmData);
 
 /*
  * Schedule an Ion compilation for a script, given a builder which has been
  * generated and read everything needed from the VM state.
  */
 bool
 StartOffThreadIonCompile(JSContext *cx, jit::IonBuilder *builder);
 
-#endif // JS_ION
-
 /*
  * Cancel a scheduled or in progress Ion compilation for script. If script is
  * nullptr, all compilations for the compartment are cancelled.
  */
 void
 CancelOffThreadIonCompile(JSCompartment *compartment, JSScript *script);
 
 /* Cancel all scheduled, in progress or finished parses for runtime. */
@@ -397,17 +393,16 @@ class AutoUnlockHelperThreadState
     }
 
     ~AutoUnlockHelperThreadState()
     {
         HelperThreadState().lock();
     }
 };
 
-#ifdef JS_ION
 struct AsmJSParallelTask
 {
     JSRuntime *runtime;     // Associated runtime.
     LifoAlloc lifo;         // Provider of all heap memory used for compilation.
     void *func;             // Really, a ModuleCompiler::Func*
     jit::MIRGenerator *mir; // Passed from main thread to helper.
     jit::LIRGraph *lir;     // Passed from helper to main thread.
     unsigned compileTime;
@@ -418,17 +413,16 @@ struct AsmJSParallelTask
 
     void init(JSRuntime *rt, void *func, jit::MIRGenerator *mir) {
         this->runtime = rt;
         this->func = func;
         this->mir = mir;
         this->lir = nullptr;
     }
 };
-#endif
 
 struct ParseTask
 {
     ExclusiveContext *cx;
     OwningCompileOptions options;
     const jschar *chars;
     size_t length;
     LifoAlloc alloc;
--- a/js/src/vm/Interpreter-inl.h
+++ b/js/src/vm/Interpreter-inl.h
@@ -657,30 +657,27 @@ ReportIfNotFunction(JSContext *cx, Handl
  * just call Invoke. If the callee has a valid IonScript, however, it will enter
  * Ion directly.
  */
 class FastInvokeGuard
 {
     InvokeArgs args_;
     RootedFunction fun_;
     RootedScript script_;
-#ifdef JS_ION
+
     // Constructing an IonContext is pretty expensive due to the TLS access,
     // so only do this if we have to.
     bool useIon_;
-#endif
 
   public:
     FastInvokeGuard(JSContext *cx, const Value &fval)
       : args_(cx)
       , fun_(cx)
       , script_(cx)
-#ifdef JS_ION
       , useIon_(jit::IsIonEnabled(cx))
-#endif
     {
         JS_ASSERT(!InParallelSection());
         initFunction(fval);
     }
 
     void initFunction(const Value &fval) {
         if (fval.isObject() && fval.toObject().is<JSFunction>()) {
             JSFunction *fun = &fval.toObject().as<JSFunction>();
@@ -689,17 +686,16 @@ class FastInvokeGuard
         }
     }
 
     InvokeArgs &args() {
         return args_;
     }
 
     bool invoke(JSContext *cx) {
-#ifdef JS_ION
         if (useIon_ && fun_) {
             if (!script_) {
                 script_ = fun_->getOrCreateScript(cx);
                 if (!script_)
                     return false;
             }
             JS_ASSERT(fun_->nonLazyScript() == script_);
 
@@ -718,17 +714,16 @@ class FastInvokeGuard
             JS_ASSERT(status == jit::Method_Skipped);
 
             if (script_->canIonCompile()) {
                 // This script is not yet hot. Since calling into Ion is much
                 // faster here, bump the use count a bit to account for this.
                 script_->incUseCount(5);
             }
         }
-#endif
 
         return Invoke(cx, args_);
     }
 
   private:
     FastInvokeGuard(const FastInvokeGuard& other) MOZ_DELETE;
     const FastInvokeGuard& operator=(const FastInvokeGuard& other) MOZ_DELETE;
 };
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -378,17 +378,16 @@ js::RunScript(JSContext *cx, RunState &s
     if (AssertOnScriptEntryHook hook = cx->runtime()->assertOnScriptEntryHook_)
         (*hook)(cx, state.script());
 #endif
 
     SPSEntryMarker marker(cx->runtime(), state.script());
 
     state.script()->ensureNonLazyCanonicalFunction(cx);
 
-#ifdef JS_ION
     if (jit::IsIonEnabled(cx)) {
         jit::MethodStatus status = jit::CanEnter(cx, state);
         if (status == jit::Method_Error)
             return false;
         if (status == jit::Method_Compiled) {
             jit::IonExecStatus status = jit::IonCannon(cx, state);
             return !IsErrorStatus(status);
         }
@@ -398,17 +397,16 @@ js::RunScript(JSContext *cx, RunState &s
         jit::MethodStatus status = jit::CanEnterBaselineMethod(cx, state);
         if (status == jit::Method_Error)
             return false;
         if (status == jit::Method_Compiled) {
             jit::IonExecStatus status = jit::EnterBaselineMethod(cx, state);
             return !IsErrorStatus(status);
         }
     }
-#endif
 
     if (state.isInvoke()) {
         InvokeState &invoke = *state.asInvoke();
         TypeMonitorCall(cx, invoke.args(), invoke.constructing());
     }
 
     return Interpret(cx, state);
 }
@@ -1283,27 +1281,25 @@ ModOperation(JSContext *cx, HandleValue 
 }
 
 static MOZ_ALWAYS_INLINE bool
 SetObjectElementOperation(JSContext *cx, Handle<JSObject*> obj, HandleId id, const Value &value,
                           bool strict, JSScript *script = nullptr, jsbytecode *pc = nullptr)
 {
     types::TypeScript::MonitorAssign(cx, obj, id);
 
-#ifdef JS_ION
     if (obj->isNative() && JSID_IS_INT(id)) {
         uint32_t length = obj->getDenseInitializedLength();
         int32_t i = JSID_TO_INT(id);
         if ((uint32_t)i >= length) {
             // Annotate script if provided with information (e.g. baseline)
             if (script && script->hasBaselineScript() && *pc == JSOP_SETELEM)
                 script->baselineScript()->noteArrayWriteHole(script->pcToOffset(pc));
         }
     }
-#endif
 
     if (obj->isNative() && !JSID_IS_INT(id) && !obj->setHadElementsAccess(cx))
         return false;
 
     RootedValue tmp(cx, value);
     return JSObject::setGeneric(cx, obj, obj, id, &tmp, strict);
 }
 
@@ -1676,18 +1672,16 @@ CASE(JSOP_TRY)
 
 CASE(JSOP_LOOPHEAD)
 END_CASE(JSOP_LOOPHEAD)
 
 CASE(JSOP_LABEL)
 END_CASE(JSOP_LABEL)
 
 CASE(JSOP_LOOPENTRY)
-
-#ifdef JS_ION
     // Attempt on-stack replacement with Baseline code.
     if (jit::IsBaselineEnabled(cx)) {
         jit::MethodStatus status = jit::CanEnterBaselineAtBranch(cx, REGS.fp(), false);
         if (status == jit::Method_Error)
             goto error;
         if (status == jit::Method_Compiled) {
             bool wasSPS = REGS.fp()->hasPushedSPSFrame();
             jit::IonExecStatus maybeOsr = jit::EnterBaselineAtBranch(cx, REGS.fp(), REGS.pc);
@@ -1703,18 +1697,16 @@ CASE(JSOP_LOOPENTRY)
             if (wasSPS)
                 cx->runtime()->spsProfiler.exit(script, script->functionNonDelazifying());
 
             if (activation.entryFrame() != REGS.fp())
                 goto jit_return_pop_frame;
             goto leave_on_safe_point;
         }
     }
-#endif /* JS_ION */
-
 END_CASE(JSOP_LOOPENTRY)
 
 CASE(JSOP_LINENO)
 END_CASE(JSOP_LINENO)
 
 CASE(JSOP_UNDEFINED)
     PUSH_UNDEFINED();
 END_CASE(JSOP_UNDEFINED)
@@ -1786,26 +1778,22 @@ CASE(JSOP_RETRVAL)
             interpReturnOK = ScriptDebugEpilogue(cx, REGS.fp(), REGS.pc, interpReturnOK);
 
         if (!REGS.fp()->isYielding())
             REGS.fp()->epilogue(cx);
         else
             probes::ExitScript(cx, script, script->functionNonDelazifying(),
                                REGS.fp()->hasPushedSPSFrame());
 
-#if defined(JS_ION)
   jit_return_pop_frame:
-#endif
 
         activation.popInlineFrame(REGS.fp());
         SET_SCRIPT(REGS.fp()->script());
 
-#if defined(JS_ION)
   jit_return:
-#endif
 
         JS_ASSERT(js_CodeSpec[*REGS.pc].format & JOF_INVOKE);
 
         /* Resume execution in the calling frame. */
         if (MOZ_LIKELY(interpReturnOK)) {
             TypeScript::Monitor(cx, script, REGS.pc, REGS.sp[-1]);
 
             ADVANCE_AND_DISPATCH(JSOP_CALL_LENGTH);
@@ -2564,17 +2552,16 @@ CASE(JSOP_FUNCALL)
         ADVANCE_AND_DISPATCH(JSOP_CALL_LENGTH);
     }
 
     InitialFrameFlags initial = construct ? INITIAL_CONSTRUCT : INITIAL_NONE;
     bool newType = UseNewType(cx, script, REGS.pc);
 
     TypeMonitorCall(cx, args, construct);
 
-#ifdef JS_ION
     {
         InvokeState state(cx, args, initial);
         if (newType)
             state.setUseNewType();
 
         if (!newType && jit::IsIonEnabled(cx)) {
             jit::MethodStatus status = jit::CanEnter(cx, state);
             if (status == jit::Method_Error)
@@ -2596,17 +2583,16 @@ CASE(JSOP_FUNCALL)
                 jit::IonExecStatus exec = jit::EnterBaselineMethod(cx, state);
                 CHECK_BRANCH();
                 REGS.sp = args.spAfterCall();
                 interpReturnOK = !IsErrorStatus(exec);
                 goto jit_return;
             }
         }
     }
-#endif
 
     funScript = fun->nonLazyScript();
     if (!activation.pushInlineFrame(args, funScript, initial))
         goto error;
 
     if (newType)
         REGS.fp()->setUseNewType();
 
@@ -3415,23 +3401,21 @@ DEFAULT()
         probes::ExitScript(cx, script, script->functionNonDelazifying(),
                            REGS.fp()->hasPushedSPSFrame());
 
     gc::MaybeVerifyBarriers(cx, true);
 
     TraceLogStopEvent(logger);
     TraceLogStopEvent(logger, scriptLogId);
 
-#ifdef JS_ION
     /*
      * This path is used when it's guaranteed the method can be finished
      * inside the JIT.
      */
   leave_on_safe_point:
-#endif
 
     if (interpReturnOK)
         state.setReturnValue(activation.entryFrame()->returnValue());
 
     return interpReturnOK;
 }
 
 bool
--- a/js/src/vm/MemoryMetrics.cpp
+++ b/js/src/vm/MemoryMetrics.cpp
@@ -441,21 +441,19 @@ StatsCellCallback(JSRuntime *rt, void *d
       }
 
       case JSTRACE_SCRIPT: {
         JSScript *script = static_cast<JSScript *>(thing);
         CompartmentStats *cStats = GetCompartmentStats(script->compartment());
         cStats->scriptsGCHeap += thingSize;
         cStats->scriptsMallocHeapData += script->sizeOfData(rtStats->mallocSizeOf_);
         cStats->typeInferenceTypeScripts += script->sizeOfTypeScript(rtStats->mallocSizeOf_);
-#ifdef JS_ION
         jit::AddSizeOfBaselineData(script, rtStats->mallocSizeOf_, &cStats->baselineData,
                                    &cStats->baselineStubsFallback);
         cStats->ionData += jit::SizeOfIonData(script, rtStats->mallocSizeOf_);
-#endif
 
         ScriptSource *ss = script->scriptSource();
         SourceSet::AddPtr entry = closure->seenSources.lookupForAdd(ss);
         if (!entry) {
             (void)closure->seenSources.add(entry, ss); // Not much to be done on failure.
 
             JS::ScriptSourceInfo info;  // This zeroes all the sizes.
             ss->addSizeOfIncludingThis(rtStats->mallocSizeOf_, &info);
@@ -485,20 +483,18 @@ StatsCellCallback(JSRuntime *rt, void *d
       case JSTRACE_LAZY_SCRIPT: {
         LazyScript *lazy = static_cast<LazyScript *>(thing);
         zStats->lazyScriptsGCHeap += thingSize;
         zStats->lazyScriptsMallocHeap += lazy->sizeOfExcludingThis(rtStats->mallocSizeOf_);
         break;
       }
 
       case JSTRACE_JITCODE: {
-#ifdef JS_ION
         zStats->jitCodesGCHeap += thingSize;
         // The code for a script is counted in ExecutableAllocator::sizeOfCode().
-#endif
         break;
       }
 
       case JSTRACE_TYPE_OBJECT: {
         types::TypeObject *obj = static_cast<types::TypeObject *>(thing);
         zStats->typeObjectsGCHeap += thingSize;
         zStats->typeObjectsMallocHeap += obj->sizeOfExcludingThis(rtStats->mallocSizeOf_);
         break;
--- a/js/src/vm/OldDebugAPI.cpp
+++ b/js/src/vm/OldDebugAPI.cpp
@@ -257,17 +257,16 @@ JS_DumpCompartmentPCCounts(JSContext *cx
         RootedScript script(cx, i.get<JSScript>());
         if (script->compartment() != cx->compartment())
             continue;
 
         if (script->hasScriptCounts())
             JS_DumpPCCounts(cx, script);
     }
 
-#if defined(JS_ION)
     for (unsigned thingKind = FINALIZE_OBJECT0; thingKind < FINALIZE_OBJECT_LIMIT; thingKind++) {
         for (ZoneCellIter i(cx->zone(), (AllocKind) thingKind); !i.done(); i.next()) {
             JSObject *obj = i.get<JSObject>();
             if (obj->compartment() != cx->compartment())
                 continue;
 
             if (obj->is<AsmJSModuleObject>()) {
                 AsmJSModule &module = obj->as<AsmJSModuleObject>().module();
@@ -283,17 +282,16 @@ JS_DumpCompartmentPCCounts(JSContext *cx
                     DumpIonScriptCounts(&sprinter, counts);
                 }
 
                 fputs(sprinter.string(), stdout);
                 fprintf(stdout, "--- END Asm.js Module ---\n");
             }
         }
     }
-#endif
 }
 
 static const char *
 FormatValue(JSContext *cx, const Value &vArg, JSAutoByteString &bytes)
 {
     RootedValue v(cx, vArg);
 
     /*
--- a/js/src/vm/RegExpObject.cpp
+++ b/js/src/vm/RegExpObject.cpp
@@ -446,22 +446,21 @@ void
 RegExpShared::trace(JSTracer *trc)
 {
     if (IS_GC_MARKING_TRACER(trc))
         marked_ = true;
 
     if (source)
         MarkString(trc, &source, "RegExpShared source");
 
-#ifdef JS_ION
     if (jitCodeLatin1)
         MarkJitCode(trc, &jitCodeLatin1, "RegExpShared code Latin1");
+
     if (jitCodeTwoByte)
         MarkJitCode(trc, &jitCodeTwoByte, "RegExpShared code TwoByte");
-#endif
 }
 
 bool
 RegExpShared::compile(JSContext *cx, HandleLinearString input)
 {
     TraceLogger *logger = TraceLoggerForMainThread(cx->runtime());
     AutoTraceLog logCompile(logger, TraceLogger::IrregexpCompile);
 
@@ -516,23 +515,21 @@ RegExpShared::compile(JSContext *cx, Han
 
     irregexp::RegExpCode code = irregexp::CompilePattern(cx, this, &data, input,
                                                          false /* global() */,
                                                          ignoreCase(),
                                                          input->hasLatin1Chars());
     if (code.empty())
         return false;
 
-#ifdef JS_ION
     JS_ASSERT(!code.jitCode || !code.byteCode);
     if (input->hasLatin1Chars())
         jitCodeLatin1 = code.jitCode;
     else
         jitCodeTwoByte = code.jitCode;
-#endif
 
     if (input->hasLatin1Chars())
         byteCodeLatin1 = code.byteCode;
     else
         byteCodeTwoByte = code.byteCode;
 
     return true;
 }
@@ -611,17 +608,16 @@ RegExpShared::execute(JSContext *cx, Han
         if (result == RegExpRunStatus_Success) {
             matches.displace(displacement);
             matches.checkAgainst(origLength);
             *lastIndex = matches[0].limit;
         }
         return result;
     }
 
-#ifdef JS_ION
     while (true) {
         RegExpRunStatus result;
         {
             AutoTraceLog logJIT(logger, TraceLogger::IrregexpExecute);
             AutoCheckCannotGC nogc;
             if (input->hasLatin1Chars()) {
                 const Latin1Char *chars = input->latin1Chars(nogc) + charsOffset;
                 result = irregexp::ExecuteCode(cx, jitCodeLatin1, chars, start, length, &matches);
@@ -652,19 +648,16 @@ RegExpShared::execute(JSContext *cx, Han
         }
 
         if (result == RegExpRunStatus_Success_NotFound)
             return RegExpRunStatus_Success_NotFound;
 
         JS_ASSERT(result == RegExpRunStatus_Success);
         break;
     }
-#else // JS_ION
-    MOZ_CRASH();
-#endif // JS_ION
 
     matches.displace(displacement);
     matches.checkAgainst(origLength);
     *lastIndex = matches[0].limit;
     return RegExpRunStatus_Success;
 }
 
 size_t
@@ -760,22 +753,20 @@ RegExpCompartment::sweep(JSRuntime *rt)
         // restarted while in progress (i.e. performing a full GC in the
         // middle of an incremental GC) or if a RegExpShared referenced via the
         // stack is traced but is not in a zone being collected.
         //
         // Because of this we only treat the marked_ bit as a hint, and destroy
         // the RegExpShared if it was accidentally marked earlier but wasn't
         // marked by the current trace.
         bool keep = shared->marked() && !IsStringAboutToBeFinalized(shared->source.unsafeGet());
-#ifdef JS_ION
         if (keep && shared->jitCodeLatin1)
             keep = !IsJitCodeAboutToBeFinalized(shared->jitCodeLatin1.unsafeGet());
         if (keep && shared->jitCodeTwoByte)
             keep = !IsJitCodeAboutToBeFinalized(shared->jitCodeTwoByte.unsafeGet());
-#endif
         if (keep) {
             shared->clearMarked();
         } else {
             js_delete(shared);
             e.removeFront();
         }
     }
 
--- a/js/src/vm/RegExpObject.h
+++ b/js/src/vm/RegExpObject.h
@@ -107,20 +107,18 @@ class RegExpShared
     /* Source to the RegExp, for lazy compilation. */
     HeapPtrAtom        source;
 
     RegExpFlag         flags;
     size_t             parenCount;
     bool               canStringMatch;
     bool               marked_;
 
-#ifdef JS_ION
     HeapPtrJitCode     jitCodeLatin1;
     HeapPtrJitCode     jitCodeTwoByte;
-#endif
     uint8_t            *byteCodeLatin1;
     uint8_t            *byteCodeTwoByte;
 
     // Tables referenced by JIT code.
     Vector<uint8_t *, 0, SystemAllocPolicy> tables;
 
     /* Internal functions. */
     bool compile(JSContext *cx, HandleLinearString input);
@@ -154,28 +152,20 @@ class RegExpShared
     JSAtom *getSource() const           { return source; }
     RegExpFlag getFlags() const         { return flags; }
     bool ignoreCase() const             { return flags & IgnoreCaseFlag; }
     bool global() const                 { return flags & GlobalFlag; }
     bool multiline() const              { return flags & MultilineFlag; }
     bool sticky() const                 { return flags & StickyFlag; }
 
     bool hasJitCodeLatin1() const {
-#ifdef JS_ION
         return jitCodeLatin1 != nullptr;
-#else
-        return false;
-#endif
     }
     bool hasJitCodeTwoByte() const {
-#ifdef JS_ION
         return jitCodeTwoByte != nullptr;
-#else
-        return false;
-#endif
     }
     bool hasByteCodeLatin1() const {
         return byteCodeLatin1 != nullptr;
     }
     bool hasByteCodeTwoByte() const {
         return byteCodeTwoByte != nullptr;
     }
     uint8_t *maybeByteCode(bool latin1) const {
--- a/js/src/vm/Runtime.cpp
+++ b/js/src/vm/Runtime.cpp
@@ -24,19 +24,17 @@
 #include "jsgc.h"
 #include "jsmath.h"
 #include "jsnativestack.h"
 #include "jsobj.h"
 #include "jsscript.h"
 #include "jswatchpoint.h"
 #include "jswrapper.h"
 
-#if defined(JS_ION)
-# include "assembler/assembler/MacroAssembler.h"
-#endif
+#include "assembler/assembler/MacroAssembler.h"
 #include "jit/arm/Simulator-arm.h"
 #include "jit/AsmJSSignalHandlers.h"
 #include "jit/JitCompartment.h"
 #include "jit/mips/Simulator-mips.h"
 #include "jit/PcScriptCache.h"
 #include "js/MemoryMetrics.h"
 #include "js/SliceBudget.h"
 
@@ -127,19 +125,17 @@ JSRuntime::JSRuntime(JSRuntime *parentRu
   : JS::shadow::Runtime(
 #ifdef JSGC_GENERATIONAL
         &gc.storeBuffer
 #endif
     ),
     mainThread(this),
     parentRuntime(parentRuntime),
     interrupt(false),
-#ifdef JS_ION
     interruptPar(false),
-#endif
     handlingSignal(false),
     interruptCallback(nullptr),
     interruptLock(nullptr),
     interruptLockOwner(nullptr),
     exclusiveAccessLock(nullptr),
     exclusiveAccessOwner(nullptr),
     mainThreadHasExclusiveAccess(false),
     numExclusiveThreads(0),
@@ -234,29 +230,25 @@ JSRuntime::JSRuntime(JSRuntime *parentRu
 
     PodArrayZero(nativeStackQuota);
     PodZero(&asmJSCacheOps);
 }
 
 static bool
 JitSupportsFloatingPoint()
 {
-#if defined(JS_ION)
     if (!JSC::MacroAssembler::supportsFloatingPoint())
         return false;
 
-#if defined(JS_ION) && WTF_ARM_ARCH_VERSION == 6
+#if WTF_ARM_ARCH_VERSION == 6
     if (!js::jit::HasVFP())
         return false;
 #endif
 
     return true;
-#else
-    return false;
-#endif
 }
 
 static bool
 SignalBasedTriggersDisabled()
 {
   // Don't bother trying to cache the getenv lookup; this should be called
   // infrequently.
   return !!getenv("JS_DISABLE_SLOW_SCRIPT_SIGNALS") || !!getenv("JS_NO_SIGNALS");
@@ -334,20 +326,18 @@ JSRuntime::init(uint32_t maxbytes, uint3
     if (!simulatorRuntime_)
         return false;
 #endif
 
     nativeStackBase = GetNativeStackBase();
 
     jitSupportsFloatingPoint = JitSupportsFloatingPoint();
 
-#ifdef JS_ION
     signalHandlersInstalled_ = EnsureAsmJSSignalHandlersInstalled(this);
     canUseSignalHandlers_ = signalHandlersInstalled_ && !SignalBasedTriggersDisabled();
-#endif
 
     if (!spsProfiler.init())
         return false;
 
     return true;
 }
 
 JSRuntime::~JSRuntime()
@@ -434,19 +424,17 @@ JSRuntime::~JSRuntime()
     FinishRuntimeNumberState(this);
 #endif
 
     gc.finish();
     atomsCompartment_ = nullptr;
 
     js_free(defaultLocale);
     js_delete(mathCache_);
-#ifdef JS_ION
     js_delete(jitRuntime_);
-#endif
     js_delete(execAlloc_);  /* Delete after jitRuntime_. */
 
     js_delete(ionPcScriptCache);
 
 #ifdef JSGC_GENERATIONAL
     gc.storeBuffer.disable();
     gc.nursery.disable();
 #endif
@@ -521,25 +509,23 @@ JSRuntime::addSizeOfIncludingThis(mozill
     rtSizes->compressedSourceSet += compressedSourceSet.sizeOfExcludingThis(mallocSizeOf);
 
     rtSizes->scriptData += scriptDataTable().sizeOfExcludingThis(mallocSizeOf);
     for (ScriptDataTable::Range r = scriptDataTable().all(); !r.empty(); r.popFront())
         rtSizes->scriptData += mallocSizeOf(r.front());
 
     if (execAlloc_)
         execAlloc_->addSizeOfCode(&rtSizes->code);
-#ifdef JS_ION
     {
         AutoLockForInterrupt lock(this);
         if (jitRuntime()) {
             if (JSC::ExecutableAllocator *ionAlloc = jitRuntime()->ionAlloc(this))
                 ionAlloc->addSizeOfCode(&rtSizes->code);
         }
     }
-#endif
 
     rtSizes->gc.marker += gc.marker.sizeOfExcludingThis(mallocSizeOf);
 #ifdef JSGC_GENERATIONAL
     rtSizes->gc.nurseryCommitted += gc.nursery.sizeOfHeapCommitted();
     rtSizes->gc.nurseryDecommitted += gc.nursery.sizeOfHeapDecommitted();
     rtSizes->gc.nurseryHugeSlots += gc.nursery.sizeOfHugeSlots(mallocSizeOf);
     gc.storeBuffer.addSizeOfExcludingThis(mallocSizeOf, &rtSizes->gc);
 #endif
@@ -555,28 +541,26 @@ JSRuntime::requestInterrupt(InterruptMod
      * set before interrupt, to avoid racing with js::InvokeInterruptCallback,
      * into a weird state where interrupt is stuck at 0 but jitStackLimit is
      * MAXADDR.
      */
     mainThread.setJitStackLimit(-1);
 
     interrupt = true;
 
-#ifdef JS_ION
     RequestInterruptForForkJoin(this, mode);
 
     /*
      * asm.js and normal Ion code optionally use memory protection and signal
      * handlers to halt running code.
      */
     if (canUseSignalHandlers()) {
         RequestInterruptForAsmJSCode(this, mode);
         jit::RequestInterruptForIonCode(this, mode);
     }
-#endif
 }
 
 JSC::ExecutableAllocator *
 JSRuntime::createExecutableAllocator(JSContext *cx)
 {
     JS_ASSERT(!execAlloc_);
     JS_ASSERT(cx->runtime() == this);
 
--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -715,24 +715,22 @@ struct JSRuntime : public JS::shadow::Ru
     JSRuntime *parentRuntime;
 
     /*
      * If true, we've been asked to call the interrupt callback as soon as
      * possible.
      */
     mozilla::Atomic<bool, mozilla::Relaxed> interrupt;
 
-#ifdef JS_ION
     /*
      * If non-zero, ForkJoin should service an interrupt. This is a separate
      * flag from |interrupt| because we cannot use the mprotect trick with PJS
      * code and ignore the TriggerCallbackAnyThreadDontStopIon trigger.
      */
     mozilla::Atomic<bool, mozilla::Relaxed> interruptPar;
-#endif
 
     /* Set when handling a signal for a thread associated with this runtime. */
     bool handlingSignal;
 
     JSInterruptCallback interruptCallback;
 
 #ifdef DEBUG
     void assertCanLock(js::RuntimeLock which);
@@ -1038,17 +1036,17 @@ struct JSRuntime : public JS::shadow::Ru
      * Head of circular list of all enabled Debuggers that have
      * onNewGlobalObject handler methods established.
      */
     JSCList             onNewGlobalObjectWatchers;
 
     /* Client opaque pointers */
     void                *data;
 
-#if defined(XP_MACOSX) && defined(JS_ION)
+#ifdef XP_MACOSX
     js::AsmJSMachExceptionHandler asmJSMachExceptionHandler;
 #endif
 
   private:
     // Whether asm.js signal handlers have been installed and can be used for
     // performing interrupt checks in loops.
     bool signalHandlersInstalled_;
     // Whether we should use them or they have been disabled for making
--- a/js/src/vm/SPSProfiler.cpp
+++ b/js/src/vm/SPSProfiler.cpp
@@ -81,24 +81,22 @@ SPSProfiler::enable(bool enabled)
     /*
      * Ensure all future generated code will be instrumented, or that all
      * currently instrumented code is discarded
      */
     ReleaseAllJITCode(rt->defaultFreeOp());
 
     enabled_ = enabled;
 
-#ifdef JS_ION
     /* Toggle SPS-related jumps on baseline jitcode.
      * The call to |ReleaseAllJITCode| above will release most baseline jitcode, but not
      * jitcode for scripts with active frames on the stack.  These scripts need to have
      * their profiler state toggled so they behave properly.
      */
     jit::ToggleBaselineSPS(rt, enabled);
-#endif
 }
 
 /* Lookup the string for the function/script, creating one if necessary */
 const char*
 SPSProfiler::profileString(JSScript *script, JSFunction *maybeFun)
 {
     AutoSPSLock lock(lock_);
     JS_ASSERT(strings.initialized());
--- a/js/src/vm/Stack-inl.h
+++ b/js/src/vm/Stack-inl.h
@@ -332,213 +332,157 @@ FrameIter::unaliasedForEachActual(JSCont
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case INTERP:
         interpFrame()->unaliasedForEachActual(op);
         return;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS()) {
             ionInlineFrames_.unaliasedForEachActual(cx, op, jit::ReadFrame_Actuals);
         } else {
             JS_ASSERT(data_.jitFrames_.isBaselineJS());
             data_.jitFrames_.unaliasedForEachActual(op, jit::ReadFrame_Actuals);
         }
         return;
-#else
-        break;
-#endif
     }
     MOZ_CRASH("Unexpected state");
 }
 
 inline HandleValue
 AbstractFramePtr::returnValue() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->returnValue();
-#ifdef JS_ION
     return asBaselineFrame()->returnValue();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline void
 AbstractFramePtr::setReturnValue(const Value &rval) const
 {
     if (isInterpreterFrame()) {
         asInterpreterFrame()->setReturnValue(rval);
         return;
     }
-#ifdef JS_ION
     asBaselineFrame()->setReturnValue(rval);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline JSObject *
 AbstractFramePtr::scopeChain() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->scopeChain();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->scopeChain();
     return asRematerializedFrame()->scopeChain();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline void
 AbstractFramePtr::pushOnScopeChain(ScopeObject &scope)
 {
     if (isInterpreterFrame()) {
         asInterpreterFrame()->pushOnScopeChain(scope);
         return;
     }
-#ifdef JS_ION
     asBaselineFrame()->pushOnScopeChain(scope);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline CallObject &
 AbstractFramePtr::callObj() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->callObj();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->callObj();
     return asRematerializedFrame()->callObj();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::initFunctionScopeObjects(JSContext *cx)
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->initFunctionScopeObjects(cx);
-#ifdef JS_ION
     return asBaselineFrame()->initFunctionScopeObjects(cx);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline JSCompartment *
 AbstractFramePtr::compartment() const
 {
     return scopeChain()->compartment();
 }
 
 inline unsigned
 AbstractFramePtr::numActualArgs() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->numActualArgs();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->numActualArgs();
     return asRematerializedFrame()->numActualArgs();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline unsigned
 AbstractFramePtr::numFormalArgs() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->numFormalArgs();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->numFormalArgs();
     return asRematerializedFrame()->numActualArgs();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value &
 AbstractFramePtr::unaliasedVar(uint32_t i, MaybeCheckAliasing checkAliasing)
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->unaliasedVar(i, checkAliasing);
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->unaliasedVar(i, checkAliasing);
     return asRematerializedFrame()->unaliasedVar(i, checkAliasing);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value &
 AbstractFramePtr::unaliasedLocal(uint32_t i, MaybeCheckAliasing checkAliasing)
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->unaliasedLocal(i, checkAliasing);
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->unaliasedLocal(i, checkAliasing);
     return asRematerializedFrame()->unaliasedLocal(i, checkAliasing);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value &
 AbstractFramePtr::unaliasedFormal(unsigned i, MaybeCheckAliasing checkAliasing)
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->unaliasedFormal(i, checkAliasing);
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->unaliasedFormal(i, checkAliasing);
     return asRematerializedFrame()->unaliasedFormal(i, checkAliasing);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value &
 AbstractFramePtr::unaliasedActual(unsigned i, MaybeCheckAliasing checkAliasing)
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->unaliasedActual(i, checkAliasing);
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->unaliasedActual(i, checkAliasing);
     return asRematerializedFrame()->unaliasedActual(i, checkAliasing);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::hasCallObj() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->hasCallObj();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->hasCallObj();
     return asRematerializedFrame()->hasCallObj();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::useNewType() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->useNewType();
     return false;
@@ -560,327 +504,239 @@ AbstractFramePtr::isYielding() const
     return false;
 }
 
 inline bool
 AbstractFramePtr::isFunctionFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isFunctionFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isFunctionFrame();
     return asRematerializedFrame()->isFunctionFrame();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::isGlobalFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isGlobalFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isGlobalFrame();
     return asRematerializedFrame()->isGlobalFrame();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::isEvalFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isEvalFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isEvalFrame();
     MOZ_ASSERT(isRematerializedFrame());
     return false;
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 inline bool
 AbstractFramePtr::isDebuggerFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isDebuggerFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isDebuggerFrame();
     MOZ_ASSERT(isRematerializedFrame());
     return false;
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::hasArgs() const {
     return isNonEvalFunctionFrame();
 }
 
 inline JSScript *
 AbstractFramePtr::script() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->script();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->script();
     return asRematerializedFrame()->script();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline JSFunction *
 AbstractFramePtr::fun() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->fun();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->fun();
     return asRematerializedFrame()->fun();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline JSFunction *
 AbstractFramePtr::maybeFun() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->maybeFun();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->maybeFun();
     return asRematerializedFrame()->maybeFun();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline JSFunction *
 AbstractFramePtr::callee() const
 {
     if (isInterpreterFrame())
         return &asInterpreterFrame()->callee();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->callee();
     return asRematerializedFrame()->callee();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value
 AbstractFramePtr::calleev() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->calleev();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->calleev();
     return asRematerializedFrame()->calleev();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::isNonEvalFunctionFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isNonEvalFunctionFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isNonEvalFunctionFrame();
     return asRematerializedFrame()->isNonEvalFunctionFrame();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::isNonStrictDirectEvalFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isNonStrictDirectEvalFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isNonStrictDirectEvalFrame();
     MOZ_ASSERT(isRematerializedFrame());
     return false;
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::isStrictEvalFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->isStrictEvalFrame();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->isStrictEvalFrame();
     MOZ_ASSERT(isRematerializedFrame());
     return false;
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value *
 AbstractFramePtr::argv() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->argv();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->argv();
     return asRematerializedFrame()->argv();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::hasArgsObj() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->hasArgsObj();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->hasArgsObj();
     return asRematerializedFrame()->hasArgsObj();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline ArgumentsObject &
 AbstractFramePtr::argsObj() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->argsObj();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->argsObj();
     return asRematerializedFrame()->argsObj();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline void
 AbstractFramePtr::initArgsObj(ArgumentsObject &argsobj) const
 {
     if (isInterpreterFrame()) {
         asInterpreterFrame()->initArgsObj(argsobj);
         return;
     }
-#ifdef JS_ION
     asBaselineFrame()->initArgsObj(argsobj);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::copyRawFrameSlots(AutoValueVector *vec) const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->copyRawFrameSlots(vec);
-#ifdef JS_ION
     return asBaselineFrame()->copyRawFrameSlots(vec);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline bool
 AbstractFramePtr::prevUpToDate() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->prevUpToDate();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->prevUpToDate();
     return asRematerializedFrame()->prevUpToDate();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline void
 AbstractFramePtr::setPrevUpToDate() const
 {
     if (isInterpreterFrame()) {
         asInterpreterFrame()->setPrevUpToDate();
         return;
     }
-#ifdef JS_ION
     if (isBaselineFrame()) {
         asBaselineFrame()->setPrevUpToDate();
         return;
     }
     asRematerializedFrame()->setPrevUpToDate();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline Value &
 AbstractFramePtr::thisValue() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->thisValue();
-#ifdef JS_ION
     if (isBaselineFrame())
         return asBaselineFrame()->thisValue();
     return asRematerializedFrame()->thisValue();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline void
 AbstractFramePtr::popBlock(JSContext *cx) const
 {
     if (isInterpreterFrame()) {
         asInterpreterFrame()->popBlock(cx);
         return;
     }
-#ifdef JS_ION
     asBaselineFrame()->popBlock(cx);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 inline void
 AbstractFramePtr::popWith(JSContext *cx) const
 {
     if (isInterpreterFrame()) {
         asInterpreterFrame()->popWith(cx);
         return;
     }
-#ifdef JS_ION
     asBaselineFrame()->popWith(cx);
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 Activation::Activation(ThreadSafeContext *cx, Kind kind)
   : cx_(cx),
     compartment_(cx->compartment_),
     prev_(cx->perThreadData->activation_),
     savedFrameChain_(0),
     hideScriptedCallerCount_(0),
--- a/js/src/vm/Stack.cpp
+++ b/js/src/vm/Stack.cpp
@@ -6,22 +6,20 @@
 
 #include "vm/Stack-inl.h"
 
 #include "mozilla/PodOperations.h"
 
 #include "jscntxt.h"
 
 #include "gc/Marking.h"
-#ifdef JS_ION
 #include "jit/AsmJSFrameIterator.h"
 #include "jit/AsmJSModule.h"
 #include "jit/BaselineFrame.h"
 #include "jit/JitCompartment.h"
-#endif
 #include "js/GCAPI.h"
 #include "vm/Opcodes.h"
 
 #include "jit/JitFrameIterator-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/Probes-inl.h"
 #include "vm/ScopeObject-inl.h"
 
@@ -561,17 +559,16 @@ FrameIter::settleOnActivation()
             if (JSSubsumesOp subsumes = cx->runtime()->securityCallbacks->subsumes) {
                 if (!subsumes(data_.principals_, activation->compartment()->principals)) {
                     ++data_.activations_;
                     continue;
                 }
             }
         }
 
-#ifdef JS_ION
         if (activation->isJit()) {
             data_.jitFrames_ = jit::JitFrameIterator(data_.activations_);
 
             // Stop at the first scripted frame.
             while (!data_.jitFrames_.isScripted() && !data_.jitFrames_.done())
                 ++data_.jitFrames_;
 
             // It's possible to have an JitActivation with no scripted frames,
@@ -598,17 +595,16 @@ FrameIter::settleOnActivation()
             return;
         }
 
         // ForkJoin activations don't contain iterable frames, so skip them.
         if (activation->isForkJoin()) {
             ++data_.activations_;
             continue;
         }
-#endif
 
         JS_ASSERT(activation->isInterpreter());
 
         InterpreterActivation *interpAct = activation->asInterpreter();
         data_.interpFrames_ = InterpreterFrameIterator(interpAct);
 
         // If we OSR'ed into JIT code, skip the interpreter frame so that
         // the same frame is not reported twice.
@@ -630,101 +626,84 @@ FrameIter::settleOnActivation()
 FrameIter::Data::Data(ThreadSafeContext *cx, SavedOption savedOption,
                       ContextOption contextOption, JSPrincipals *principals)
   : cx_(cx),
     savedOption_(savedOption),
     contextOption_(contextOption),
     principals_(principals),
     pc_(nullptr),
     interpFrames_(nullptr),
-    activations_(cx->perThreadData)
-#ifdef JS_ION
-  , jitFrames_((uint8_t *)nullptr, SequentialExecution)
-  , ionInlineFrameNo_(0)
-  , asmJSFrames_()
-#endif
+    activations_(cx->perThreadData),
+    jitFrames_((uint8_t *)nullptr, SequentialExecution),
+    ionInlineFrameNo_(0),
+    asmJSFrames_()
 {
 }
 
 FrameIter::Data::Data(const FrameIter::Data &other)
   : cx_(other.cx_),
     savedOption_(other.savedOption_),
     contextOption_(other.contextOption_),
     principals_(other.principals_),
     state_(other.state_),
     pc_(other.pc_),
     interpFrames_(other.interpFrames_),
-    activations_(other.activations_)
-#ifdef JS_ION
-  , jitFrames_(other.jitFrames_)
-  , ionInlineFrameNo_(other.ionInlineFrameNo_)
-  , asmJSFrames_(other.asmJSFrames_)
-#endif
+    activations_(other.activations_),
+    jitFrames_(other.jitFrames_),
+    ionInlineFrameNo_(other.ionInlineFrameNo_),
+    asmJSFrames_(other.asmJSFrames_)
 {
 }
 
 FrameIter::FrameIter(ThreadSafeContext *cx, SavedOption savedOption)
-  : data_(cx, savedOption, CURRENT_CONTEXT, nullptr)
-#ifdef JS_ION
-  , ionInlineFrames_(cx, (js::jit::JitFrameIterator*) nullptr)
-#endif
+  : data_(cx, savedOption, CURRENT_CONTEXT, nullptr),
+    ionInlineFrames_(cx, (js::jit::JitFrameIterator*) nullptr)
 {
     // settleOnActivation can only GC if principals are given.
     JS::AutoSuppressGCAnalysis nogc;
     settleOnActivation();
 }
 
 FrameIter::FrameIter(ThreadSafeContext *cx, ContextOption contextOption,
                      SavedOption savedOption)
-  : data_(cx, savedOption, contextOption, nullptr)
-#ifdef JS_ION
-  , ionInlineFrames_(cx, (js::jit::JitFrameIterator*) nullptr)
-#endif
+  : data_(cx, savedOption, contextOption, nullptr),
+    ionInlineFrames_(cx, (js::jit::JitFrameIterator*) nullptr)
 {
     // settleOnActivation can only GC if principals are given.
     JS::AutoSuppressGCAnalysis nogc;
     settleOnActivation();
 }
 
 FrameIter::FrameIter(JSContext *cx, ContextOption contextOption,
                      SavedOption savedOption, JSPrincipals *principals)
-  : data_(cx, savedOption, contextOption, principals)
-#ifdef JS_ION
-  , ionInlineFrames_(cx, (js::jit::JitFrameIterator*) nullptr)
-#endif
+  : data_(cx, savedOption, contextOption, principals),
+    ionInlineFrames_(cx, (js::jit::JitFrameIterator*) nullptr)
 {
     settleOnActivation();
 }
 
 FrameIter::FrameIter(const FrameIter &other)
-  : data_(other.data_)
-#ifdef JS_ION
-  , ionInlineFrames_(other.data_.cx_,
+  : data_(other.data_),
+    ionInlineFrames_(other.data_.cx_,
                      data_.jitFrames_.isIonJS() ? &other.ionInlineFrames_ : nullptr)
-#endif
 {
 }
 
 FrameIter::FrameIter(const Data &data)
-  : data_(data)
-#ifdef JS_ION
-  , ionInlineFrames_(data.cx_, data_.jitFrames_.isIonJS() ? &data_.jitFrames_ : nullptr)
-#endif
+  : data_(data),
+    ionInlineFrames_(data.cx_, data_.jitFrames_.isIonJS() ? &data_.jitFrames_ : nullptr)
 {
     JS_ASSERT(data.cx_);
 
-#ifdef JS_ION
     if (data_.jitFrames_.isIonJS()) {
         while (ionInlineFrames_.frameNo() != data.ionInlineFrameNo_)
             ++ionInlineFrames_;
     }
-#endif
 }
 
-#ifdef JS_ION
 void
 FrameIter::nextJitFrame()
 {
     if (data_.jitFrames_.isIonJS()) {
         ionInlineFrames_.resetOn(&data_.jitFrames_);
         data_.pc_ = ionInlineFrames_.pc();
     } else {
         JS_ASSERT(data_.jitFrames_.isBaselineJS());
@@ -759,17 +738,16 @@ void
 FrameIter::popAsmJSFrame()
 {
     JS_ASSERT(data_.state_ == ASMJS);
 
     ++data_.asmJSFrames_;
     if (data_.asmJSFrames_.done())
         popActivation();
 }
-#endif
 
 FrameIter &
 FrameIter::operator++()
 {
     switch (data_.state_) {
       case DONE:
         MOZ_CRASH("Unexpected state");
       case INTERP:
@@ -782,58 +760,46 @@ FrameIter::operator++()
             ContextOption prevContextOption = data_.contextOption_;
             SavedOption prevSavedOption = data_.savedOption_;
             data_.contextOption_ = ALL_CONTEXTS;
             data_.savedOption_ = GO_THROUGH_SAVED;
 
             popInterpreterFrame();
 
             while (isIon() || abstractFramePtr() != eifPrev) {
-                if (data_.state_ == JIT) {
-#ifdef JS_ION
+                if (data_.state_ == JIT)
                     popJitFrame();
-#else
-                    MOZ_CRASH("Invalid state");
-#endif
-                } else {
+                else
                     popInterpreterFrame();
-                }
             }
 
             data_.contextOption_ = prevContextOption;
             data_.savedOption_ = prevSavedOption;
             data_.cx_ = data_.activations_->cx();
             break;
         }
         popInterpreterFrame();
         break;
-#ifdef JS_ION
       case JIT:
         popJitFrame();
         break;
       case ASMJS:
         popAsmJSFrame();
         break;
-#else
-    default:
-        MOZ_CRASH("Unexpected state");
-#endif
     }
     return *this;
 }
 
 FrameIter::Data *
 FrameIter::copyData() const
 {
     Data *data = data_.cx_->new_<Data>(data_);
-#ifdef JS_ION
     JS_ASSERT(data_.state_ != ASMJS);
     if (data && data_.jitFrames_.isIonJS())
         data->ionInlineFrameNo_ = ionInlineFrames_.frameNo();
-#endif
     return data;
 }
 
 AbstractFramePtr
 FrameIter::copyDataAsAbstractFramePtr() const
 {
     AbstractFramePtr frame;
     if (Data *data = copyData())
@@ -859,70 +825,58 @@ bool
 FrameIter::isFunctionFrame() const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
         return interpFrame()->isFunctionFrame();
       case JIT:
-#ifdef JS_ION
         JS_ASSERT(data_.jitFrames_.isScripted());
         if (data_.jitFrames_.isBaselineJS())
             return data_.jitFrames_.isFunctionFrame();
         return ionInlineFrames_.isFunctionFrame();
-#else
-        break;
-#endif
       case ASMJS:
         return true;
     }
     MOZ_CRASH("Unexpected state");
 }
 
 bool
 FrameIter::isGlobalFrame() const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
         return interpFrame()->isGlobalFrame();
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS())
             return data_.jitFrames_.baselineFrame()->isGlobalFrame();
         JS_ASSERT(!script()->isForEval());
         return !script()->functionNonDelazifying();
-#else
-        break;
-#endif
       case ASMJS:
         return false;
     }
     MOZ_CRASH("Unexpected state");
 }
 
 bool
 FrameIter::isEvalFrame() const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
         return interpFrame()->isEvalFrame();
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS())
             return data_.jitFrames_.baselineFrame()->isEvalFrame();
         JS_ASSERT(!script()->isForEval());
         return false;
-#else
-        break;
-#endif
       case ASMJS:
         return false;
     }
     MOZ_CRASH("Unexpected state");
 }
 
 bool
 FrameIter::isNonEvalFunctionFrame() const
@@ -963,183 +917,149 @@ FrameIter::functionDisplayAtom() const
     JS_ASSERT(isNonEvalFunctionFrame());
 
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
       case JIT:
         return callee()->displayAtom();
-      case ASMJS: {
-#ifdef JS_ION
+      case ASMJS:
         return data_.asmJSFrames_.functionDisplayAtom();
-#else
-        break;
-#endif
-      }
     }
 
     MOZ_CRASH("Unexpected state");
 }
 
 ScriptSource *
 FrameIter::scriptSource() const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
       case JIT:
         return script()->scriptSource();
       case ASMJS:
-#ifdef JS_ION
         return data_.activations_->asAsmJS()->module().scriptSource();
-#else
-        break;
-#endif
     }
 
     MOZ_CRASH("Unexpected state");
 }
 
 const char *
 FrameIter::scriptFilename() const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
       case JIT:
         return script()->filename();
       case ASMJS:
-#ifdef JS_ION
         return data_.activations_->asAsmJS()->module().scriptSource()->filename();
-#else
-        break;
-#endif
     }
 
     MOZ_CRASH("Unexpected state");
 }
 
 unsigned
 FrameIter::computeLine(uint32_t *column) const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
       case JIT:
         return PCToLineNumber(script(), pc(), column);
       case ASMJS:
-#ifdef JS_ION
         return data_.asmJSFrames_.computeLine(column);
-#else
-        break;
-#endif
     }
 
     MOZ_CRASH("Unexpected state");
 }
 
 JSPrincipals *
 FrameIter::originPrincipals() const
 {
     switch (data_.state_) {
       case DONE:
         break;
       case INTERP:
       case JIT:
         return script()->originPrincipals();
-      case ASMJS: {
-#ifdef JS_ION
+      case ASMJS:
         return data_.activations_->asAsmJS()->module().scriptSource()->originPrincipals();
-#else
-        break;
-#endif
-      }
     }
 
     MOZ_CRASH("Unexpected state");
 }
 
 bool
 FrameIter::isConstructing() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS())
             return ionInlineFrames_.isConstructing();
         JS_ASSERT(data_.jitFrames_.isBaselineJS());
         return data_.jitFrames_.isConstructing();
-#else
-        break;
-#endif
       case INTERP:
         return interpFrame()->isConstructing();
     }
 
     MOZ_CRASH("Unexpected state");
 }
 
 bool
 FrameIter::ensureHasRematerializedFrame(ThreadSafeContext *cx)
 {
-#ifdef JS_ION
     MOZ_ASSERT(isIon());
     return !!activation()->asJit()->getRematerializedFrame(cx, data_.jitFrames_);
-#else
-    return true;
-#endif
 }
 
 bool
 FrameIter::hasUsableAbstractFramePtr() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         return false;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS())
             return true;
 
         MOZ_ASSERT(data_.jitFrames_.isIonJS());
         return !!activation()->asJit()->lookupRematerializedFrame(data_.jitFrames_.fp(),
                                                                   ionInlineFrames_.frameNo());
-#endif
         break;
       case INTERP:
         return true;
     }
     MOZ_CRASH("Unexpected state");
 }
 
 AbstractFramePtr
 FrameIter::abstractFramePtr() const
 {
     MOZ_ASSERT(hasUsableAbstractFramePtr());
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT: {
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS())
             return data_.jitFrames_.baselineFrame();
 
         MOZ_ASSERT(data_.jitFrames_.isIonJS());
         return activation()->asJit()->lookupRematerializedFrame(data_.jitFrames_.fp(),
                                                                 ionInlineFrames_.frameNo());
-#endif
         break;
       }
       case INTERP:
         JS_ASSERT(interpFrame());
         return AbstractFramePtr(interpFrame());
     }
     MOZ_CRASH("Unexpected state");
 }
@@ -1161,17 +1081,16 @@ FrameIter::updatePcQuadratic()
             ++data_.interpFrames_;
 
         // Update the pc.
         JS_ASSERT(data_.interpFrames_.frame() == frame);
         data_.pc_ = data_.interpFrames_.pc();
         return;
       }
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS()) {
             jit::BaselineFrame *frame = data_.jitFrames_.baselineFrame();
             jit::JitActivation *activation = data_.activations_->asJit();
 
             // ActivationIterator::jitTop_ may be invalid, so create a new
             // activation iterator.
             data_.activations_ = ActivationIterator(data_.cx_->perThreadData);
             while (data_.activations_.activation() != activation)
@@ -1182,85 +1101,72 @@ FrameIter::updatePcQuadratic()
             while (!data_.jitFrames_.isBaselineJS() || data_.jitFrames_.baselineFrame() != frame)
                 ++data_.jitFrames_;
 
             // Update the pc.
             JS_ASSERT(data_.jitFrames_.baselineFrame() == frame);
             data_.jitFrames_.baselineScriptAndPc(nullptr, &data_.pc_);
             return;
         }
-#endif
         break;
     }
     MOZ_CRASH("Unexpected state");
 }
 
 JSFunction *
 FrameIter::callee() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case INTERP:
         JS_ASSERT(isFunctionFrame());
         return &interpFrame()->callee();
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS())
             return data_.jitFrames_.callee();
         JS_ASSERT(data_.jitFrames_.isIonJS());
         return ionInlineFrames_.callee();
-#else
-        break;
-#endif
     }
     MOZ_CRASH("Unexpected state");
 }
 
 Value
 FrameIter::calleev() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case INTERP:
         JS_ASSERT(isFunctionFrame());
         return interpFrame()->calleev();
       case JIT:
-#ifdef JS_ION
         return ObjectValue(*callee());
-#else
-        break;
-#endif
     }
     MOZ_CRASH("Unexpected state");
 }
 
 unsigned
 FrameIter::numActualArgs() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case INTERP:
         JS_ASSERT(isFunctionFrame());
         return interpFrame()->numActualArgs();
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS())
             return ionInlineFrames_.numActualArgs();
 
         JS_ASSERT(data_.jitFrames_.isBaselineJS());
         return data_.jitFrames_.numActualArgs();
-#else
-        break;
-#endif
     }
     MOZ_CRASH("Unexpected state");
 }
 
 unsigned
 FrameIter::numFormalArgs() const
 {
     return script()->functionNonDelazifying()->nargs();
@@ -1275,23 +1181,19 @@ FrameIter::unaliasedActual(unsigned i, M
 JSObject *
 FrameIter::scopeChain() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS())
             return ionInlineFrames_.scopeChain();
         return data_.jitFrames_.baselineFrame()->scopeChain();
-#else
-        break;
-#endif
       case INTERP:
         return interpFrame()->scopeChain();
     }
     MOZ_CRASH("Unexpected state");
 }
 
 CallObject &
 FrameIter::callObj() const
@@ -1334,116 +1236,100 @@ FrameIter::computedThisValue() const
 Value
 FrameIter::thisv() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS())
             return ionInlineFrames_.thisValue();
         return data_.jitFrames_.baselineFrame()->thisValue();
-#else
-        break;
-#endif
       case INTERP:
         return interpFrame()->thisValue();
     }
     MOZ_CRASH("Unexpected state");
 }
 
 Value
 FrameIter::returnValue() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS())
             return data_.jitFrames_.baselineFrame()->returnValue();
-#endif
         break;
       case INTERP:
         return interpFrame()->returnValue();
     }
     MOZ_CRASH("Unexpected state");
 }
 
 void
 FrameIter::setReturnValue(const Value &v)
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isBaselineJS()) {
             data_.jitFrames_.baselineFrame()->setReturnValue(v);
             return;
         }
-#endif
         break;
       case INTERP:
         interpFrame()->setReturnValue(v);
         return;
     }
     MOZ_CRASH("Unexpected state");
 }
 
 size_t
 FrameIter::numFrameSlots() const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT: {
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS()) {
             return ionInlineFrames_.snapshotIterator().numAllocations() -
                 ionInlineFrames_.script()->nfixed();
         }
         jit::BaselineFrame *frame = data_.jitFrames_.baselineFrame();
         return frame->numValueSlots() - data_.jitFrames_.script()->nfixed();
-#else
-        break;
-#endif
       }
       case INTERP:
         JS_ASSERT(data_.interpFrames_.sp() >= interpFrame()->base());
         return data_.interpFrames_.sp() - interpFrame()->base();
     }
     MOZ_CRASH("Unexpected state");
 }
 
 Value
 FrameIter::frameSlotValue(size_t index) const
 {
     switch (data_.state_) {
       case DONE:
       case ASMJS:
         break;
       case JIT:
-#ifdef JS_ION
         if (data_.jitFrames_.isIonJS()) {
             jit::SnapshotIterator si(ionInlineFrames_.snapshotIterator());
             index += ionInlineFrames_.script()->nfixed();
             return si.maybeReadAllocByIndex(index);
         }
 
         index += data_.jitFrames_.script()->nfixed();
         return *data_.jitFrames_.baselineFrame()->valueSlot(index);
-#else
-        break;
-#endif
       case INTERP:
           return interpFrame()->base()[index];
     }
     MOZ_CRASH("Unexpected state");
 }
 
 #if defined(_MSC_VER)
 # pragma optimize("", on)
@@ -1495,21 +1381,17 @@ AbstractFramePtr::evalPrevScopeChain(JSC
     return iter.scopeChain();
 }
 
 bool
 AbstractFramePtr::hasPushedSPSFrame() const
 {
     if (isInterpreterFrame())
         return asInterpreterFrame()->hasPushedSPSFrame();
-#ifdef JS_ION
     return asBaselineFrame()->hasPushedSPSFrame();
-#else
-    MOZ_CRASH("Invalid frame");
-#endif
 }
 
 #ifdef DEBUG
 void
 js::CheckLocalUnaliased(MaybeCheckAliasing checkAliasing, JSScript *script, uint32_t i)
 {
     if (!checkAliasing)
         return;
@@ -1522,55 +1404,49 @@ js::CheckLocalUnaliased(MaybeCheckAliasi
         // current frame, and so they do not know the block scope.
     }
 }
 #endif
 
 jit::JitActivation::JitActivation(JSContext *cx, bool firstFrameIsConstructing, bool active)
   : Activation(cx, Jit),
     firstFrameIsConstructing_(firstFrameIsConstructing),
-    active_(active)
-#ifdef JS_ION
-  , rematerializedFrames_(nullptr)
-#endif
+    active_(active),
+    rematerializedFrames_(nullptr)
 {
     if (active) {
         prevJitTop_ = cx->mainThread().jitTop;
         prevJitJSContext_ = cx->mainThread().jitJSContext;
         cx->mainThread().jitJSContext = cx;
     } else {
         prevJitTop_ = nullptr;
         prevJitJSContext_ = nullptr;
     }
 }
 
 jit::JitActivation::JitActivation(ForkJoinContext *cx)
   : Activation(cx, Jit),
     firstFrameIsConstructing_(false),
-    active_(true)
-#ifdef JS_ION
-  , rematerializedFrames_(nullptr)
-#endif
+    active_(true),
+    rematerializedFrames_(nullptr)
 {
     prevJitTop_ = cx->perThreadData->jitTop;
     prevJitJSContext_ = cx->perThreadData->jitJSContext;
     cx->perThreadData->jitJSContext = nullptr;
 }
 
 jit::JitActivation::~JitActivation()
 {
     if (active_) {
         cx_->perThreadData->jitTop = prevJitTop_;
         cx_->perThreadData->jitJSContext = prevJitJSContext_;
     }
 
-#ifdef JS_ION
     clearRematerializedFrames();
     js_delete(rematerializedFrames_);
-#endif
 }
 
 // setActive() is inlined in GenerateFFIIonExit() with explicit masm instructions so
 // changes to the logic here need to be reflected in GenerateFFIIonExit() in the enable
 // and disable activation instruction sequences.
 void
 jit::JitActivation::setActive(JSContext *cx, bool active)
 {
@@ -1585,18 +1461,16 @@ jit::JitActivation::setActive(JSContext 
         prevJitJSContext_ = cx->mainThread().jitJSContext;
         cx->mainThread().jitJSContext = cx;
     } else {
         cx->mainThread().jitTop = prevJitTop_;
         cx->mainThread().jitJSContext = prevJitJSContext_;
     }
 }
 
-#ifdef JS_ION
-
 void
 jit::JitActivation::removeRematerializedFrame(uint8_t *top)
 {
     if (!rematerializedFrames_)
         return;
 
     if (RematerializedFrameTable::Ptr p = rematerializedFrames_->lookup(top)) {
         RematerializedFrame::FreeInVector(p->value());
@@ -1722,18 +1596,16 @@ AsmJSActivation::~AsmJSActivation()
 
     JSContext *cx = cx_->asJSContext();
     JS_ASSERT(cx->mainThread().asmJSActivationStack_ == this);
 
     JSRuntime::AutoLockForInterrupt lock(cx->runtime());
     cx->mainThread().asmJSActivationStack_ = prevAsmJS_;
 }
 
-#endif // JS_ION
-
 InterpreterFrameIterator &
 InterpreterFrameIterator::operator++()
 {
     JS_ASSERT(!done());
     if (fp_ != activation_->entryFrame_) {
         pc_ = fp_->prevpc();
         sp_ = fp_->prevsp();
         fp_ = fp_->prev();
@@ -1777,78 +1649,53 @@ ActivationIterator::settle()
     // we don't iterate over an active jit activation.
     while (!done() && activation_->isJit() && !activation_->asJit()->isActive())
         activation_ = activation_->prev();
 }
 
 JS::ProfilingFrameIterator::ProfilingFrameIterator(JSRuntime *rt, const RegisterState &state)
   : activation_(rt->mainThread.asmJSActivationStack())
 {
-#ifdef JS_ION
     if (!activation_)
         return;
 
     static_assert(sizeof(AsmJSProfilingFrameIterator) <= StorageSpace, "Need to increase storage");
     new (storage_.addr()) AsmJSProfilingFrameIterator(*activation_, state);
     settle();
-#else
-    JS_ASSERT(!activation_);
-#endif
 }
 
 JS::ProfilingFrameIterator::~ProfilingFrameIterator()
 {
-#ifdef JS_ION
     if (!done())
         iter().~AsmJSProfilingFrameIterator();
-#else
-    JS_ASSERT(done());
-#endif
 }
 
 void
 JS::ProfilingFrameIterator::operator++()
 {
-#ifdef JS_ION
     JS_ASSERT(!done());
     ++iter();
     settle();
-#else
-    MOZ_CRASH("Shouldn't have any frames");
-#endif
 }
 
 void
 JS::ProfilingFrameIterator::settle()
 {
-#ifdef JS_ION
     while (iter().done()) {
         iter().~AsmJSProfilingFrameIterator();
         activation_ = activation_->prevAsmJS();
         if (!activation_)
             return;
         new (storage_.addr()) AsmJSProfilingFrameIterator(*activation_);
     }
-#else
-    MOZ_CRASH("Shouldn't have any frames");
-#endif
 }
 
 void *
 JS::ProfilingFrameIterator::stackAddress() const
 {
-#ifdef JS_ION
     return iter().stackAddress();
-#else
-    MOZ_CRASH("Shouldn't have any frames");
-#endif
 }
 
 const char *
 JS::ProfilingFrameIterator::label() const
 {
-#ifdef JS_ION
     return iter().label();
-#else
-    MOZ_CRASH("Shouldn't have any frames");
-#endif
 }
-
--- a/js/src/vm/Stack.h
+++ b/js/src/vm/Stack.h
@@ -1294,28 +1294,26 @@ namespace jit {
 // A JitActivation is used for frames running in Baseline or Ion.
 class JitActivation : public Activation
 {
     uint8_t *prevJitTop_;
     JSContext *prevJitJSContext_;
     bool firstFrameIsConstructing_;
     bool active_;
 
-#ifdef JS_ION
     // Rematerialized Ion frames which has info copied out of snapshots. Maps
     // frame pointers (i.e. jitTop) to a vector of rematerializations of all
     // inline frames associated with that frame.
     //
     // This table is lazily initialized by calling getRematerializedFrame.
     typedef Vector<RematerializedFrame *> RematerializedFrameVector;
     typedef HashMap<uint8_t *, RematerializedFrameVector> RematerializedFrameTable;
     RematerializedFrameTable *rematerializedFrames_;
 
     void clearRematerializedFrames();
-#endif
 
 #ifdef CHECK_OSIPOINT_REGISTERS
   protected:
     // Used to verify that live registers don't change between a VM call and
     // the OsiPoint that follows it. Protected to silence Clang warning.
     uint32_t checkRegs_;
     RegisterDump regs_;
 #endif
@@ -1354,17 +1352,16 @@ class JitActivation : public Activation
     static size_t offsetOfCheckRegs() {
         return offsetof(JitActivation, checkRegs_);
     }
     static size_t offsetOfRegs() {
         return offsetof(JitActivation, regs_);
     }
 #endif
 
-#ifdef JS_ION
     // Look up a rematerialized frame keyed by the fp, rematerializing the
     // frame if one doesn't already exist. A frame can only be rematerialized
     // if an IonFrameIterator pointing to the nearest uninlined frame can be
     // provided, as values need to be read out of snapshots.
     //
     // T is either JitFrameIterator or IonBailoutIterator.
     //
     // The inlineDepth must be within bounds of the frame pointed to by iter.
@@ -1379,17 +1376,16 @@ class JitActivation : public Activation
     bool hasRematerializedFrame(uint8_t *top, size_t inlineDepth = 0) {
         return !!lookupRematerializedFrame(top, inlineDepth);
     }
 
     // Remove a previous rematerialization by fp.
     void removeRematerializedFrame(uint8_t *top);
 
     void markRematerializedFrames(JSTracer *trc);
-#endif
 };
 
 // A filtering of the ActivationIterator to only stop at JitActivations.
 class JitActivationIterator : public ActivationIterator
 {
     void settle() {
         while (!done() && !activation_->isJit())
             ActivationIterator::operator++();
@@ -1550,21 +1546,19 @@ class FrameIter
 
         State               state_;
 
         jsbytecode *        pc_;
 
         InterpreterFrameIterator interpFrames_;
         ActivationIterator activations_;
 
-#ifdef JS_ION
         jit::JitFrameIterator jitFrames_;
         unsigned ionInlineFrameNo_;
         AsmJSFrameIterator asmJSFrames_;
-#endif
 
         Data(ThreadSafeContext *cx, SavedOption savedOption, ContextOption contextOption,
              JSPrincipals *principals);
         Data(const Data &other);
     };
 
     MOZ_IMPLICIT FrameIter(ThreadSafeContext *cx, SavedOption = STOP_AT_SAVED);
     FrameIter(ThreadSafeContext *cx, ContextOption, SavedOption);
@@ -1672,27 +1666,23 @@ class FrameIter
     AbstractFramePtr copyDataAsAbstractFramePtr() const;
     Data *copyData() const;
 
     // This can only be called when isInterp():
     inline InterpreterFrame *interpFrame() const;
 
   private:
     Data data_;
-#ifdef JS_ION
     jit::InlineFrameIterator ionInlineFrames_;
-#endif
 
     void popActivation();
     void popInterpreterFrame();
-#ifdef JS_ION
     void nextJitFrame();
     void popJitFrame();
     void popAsmJSFrame();
-#endif
     void settleOnActivation();
 
     friend class ::JSBrokenFrameIterator;
 };
 
 class ScriptFrameIter : public FrameIter
 {
     void settle() {
@@ -1842,44 +1832,32 @@ class AllFramesIter : public ScriptFrame
 /* Popular inline definitions. */
 
 inline JSScript *
 FrameIter::script() const
 {
     JS_ASSERT(!done());
     if (data_.state_ == INTERP)
         return interpFrame()->script();
-#ifdef JS_ION
     JS_ASSERT(data_.state_ == JIT);
     if (data_.jitFrames_.isIonJS())
         return ionInlineFrames_.script();
     return data_.jitFrames_.script();
-#else
-    return nullptr;
-#endif
 }
 
 inline bool
 FrameIter::isIon() const
 {
-#ifdef JS_ION
     return isJit() && data_.jitFrames_.isIonJS();
-#else
-    return false;
-#endif
 }
 
 inline bool
 FrameIter::isBaseline() const
 {
-#ifdef JS_ION
     return isJit() && data_.jitFrames_.isBaselineJS();
-#else
-    return false;
-#endif
 }
 
 inline InterpreterFrame *
 FrameIter::interpFrame() const
 {
     JS_ASSERT(data_.state_ == INTERP);
     return data_.interpFrames_.frame();
 }