Bug 1036781 - Part 5: Replace MOZ_ASSUME_UNREACHABLE with MOZ_CRASH in js/src/jit for Ion. r=jandem
authorChris Peterson <cpeterson@mozilla.com>
Sat, 23 Aug 2014 23:24:50 -0700
changeset 201234 bdc4a4fe462ffa522f7773e0ec53699c3a47a94d
parent 201233 5cc6986dffdeee2481a13643c1c9d72b4e669ee3
child 201235 be39ba3aa672a448a3390b6f25602ac162d86cbe
push id48123
push usercpeterson@mozilla.com
push dateSun, 24 Aug 2014 06:38:48 +0000
treeherdermozilla-inbound@bdc4a4fe462f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem
bugs1036781
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 1036781 - Part 5: Replace MOZ_ASSUME_UNREACHABLE with MOZ_CRASH in js/src/jit for Ion. r=jandem
js/src/jit/Ion.cpp
js/src/jit/IonAnalysis.cpp
js/src/jit/IonBuilder.cpp
js/src/jit/IonCaches.cpp
js/src/jit/IonCaches.h
js/src/jit/IonFrames.cpp
js/src/jit/IonFrames.h
js/src/jit/IonMacroAssembler.cpp
js/src/jit/IonMacroAssembler.h
js/src/jit/IonOptimizationLevels.cpp
js/src/jit/IonOptimizationLevels.h
js/src/jit/IonTypes.h
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -475,17 +475,17 @@ jit::RequestInterruptForIonCode(JSRuntim
 
       case JSRuntime::RequestInterruptAnyThreadDontStopIon:
       case JSRuntime::RequestInterruptAnyThreadForkJoin:
         // The caller does not require Ion code to be interrupted.
         // Nothing more needs to be done.
         break;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("Bad interrupt mode");
+        MOZ_CRASH("Bad interrupt mode");
     }
 }
 
 JitCompartment::JitCompartment()
   : stubCodes_(nullptr),
     baselineCallReturnAddr_(nullptr),
     baselineGetPropReturnAddr_(nullptr),
     baselineSetPropReturnAddr_(nullptr),
@@ -1152,31 +1152,31 @@ IonScript::getSafepointIndex(uint32_t di
         while (++guess <= maxEntry) {
             guessDisp = table[guess].displacement();
             JS_ASSERT(guessDisp <= disp);
             if (guessDisp == disp)
                 return &table[guess];
         }
     }
 
-    MOZ_ASSUME_UNREACHABLE("displacement not found.");
+    MOZ_CRASH("displacement not found.");
 }
 
 const OsiIndex *
 IonScript::getOsiIndex(uint32_t disp) const
 {
     for (const OsiIndex *it = osiIndices(), *end = osiIndices() + osiIndexEntries_;
          it != end;
          ++it)
     {
         if (it->returnPointDisplacement() == disp)
             return it;
     }
 
-    MOZ_ASSUME_UNREACHABLE("Failed to find OSI point return address");
+    MOZ_CRASH("Failed to find OSI point return address");
 }
 
 const OsiIndex *
 IonScript::getOsiIndex(uint8_t *retAddr) const
 {
     IonSpew(IonSpew_Invalidate, "IonScript %p has method %p raw %p", (void *) this, (void *)
             method(), method()->raw());
 
@@ -1697,17 +1697,17 @@ GenerateLIR(MIRGenerator *mir)
                 return nullptr;
             if (!integrity.check(true))
                 return nullptr;
             IonSpewPass("Allocate Registers [Stupid]");
             break;
           }
 
           default:
-            MOZ_ASSUME_UNREACHABLE("Bad regalloc");
+            MOZ_CRASH("Bad regalloc");
         }
 
         if (mir->shouldCancel("Allocate Registers"))
             return nullptr;
     }
 
     return lir;
 }
@@ -2575,17 +2575,17 @@ InvalidateActivation(FreeOp *fop, uint8_
           case JitFrame_BaselineStub:
             IonSpew(IonSpew_Invalidate, "#%d baseline stub frame @ %p", frameno, it.fp());
             break;
           case JitFrame_Rectifier:
             IonSpew(IonSpew_Invalidate, "#%d rectifier frame @ %p", frameno, it.fp());
             break;
           case JitFrame_Unwound_IonJS:
           case JitFrame_Unwound_BaselineStub:
-            MOZ_ASSUME_UNREACHABLE("invalid");
+            MOZ_CRASH("invalid");
           case JitFrame_Unwound_Rectifier:
             IonSpew(IonSpew_Invalidate, "#%d unwound rectifier frame @ %p", frameno, it.fp());
             break;
           case JitFrame_Entry:
             IonSpew(IonSpew_Invalidate, "#%d entry frame @ %p", frameno, it.fp());
             break;
         }
 #endif
@@ -2819,17 +2819,17 @@ jit::Invalidate(JSContext *cx, JSScript 
             return false;
         break;
       case ParallelExecution:
         JS_ASSERT(script->hasParallelIonScript());
         if (!scripts.append(script->parallelIonScript()->recompileInfo()))
             return false;
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("No such execution mode");
+        MOZ_CRASH("No such execution mode");
     }
 
     Invalidate(cx, scripts, resetUses, cancelOffThread);
     return true;
 }
 
 bool
 jit::Invalidate(JSContext *cx, JSScript *script, bool resetUses, bool cancelOffThread)
@@ -2872,17 +2872,17 @@ jit::FinishInvalidation(FreeOp *fop, JSS
         if (script->hasParallelIonScript()) {
             IonScript *parallelIon = script->parallelIonScript();
             script->setParallelIonScript(nullptr);
             FinishInvalidationOf(fop, script, parallelIon);
         }
         return;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("bad execution mode");
+        MOZ_CRASH("bad execution mode");
     }
 }
 
 template void
 jit::FinishInvalidation<SequentialExecution>(FreeOp *fop, JSScript *script);
 
 template void
 jit::FinishInvalidation<ParallelExecution>(FreeOp *fop, JSScript *script);
@@ -2921,20 +2921,20 @@ jit::ForbidCompilation(JSContext *cx, JS
             if (!Invalidate(cx, script, mode, false))
                 return;
         }
 
         script->setParallelIonScript(ION_DISABLED_SCRIPT);
         return;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("No such execution mode");
+        MOZ_CRASH("No such execution mode");
     }
 
-    MOZ_ASSUME_UNREACHABLE("No such execution mode");
+    MOZ_CRASH("No such execution mode");
 }
 
 AutoFlushICache *
 PerThreadData::autoFlushICache() const
 {
     return autoFlushICache_;
 }
 
--- a/js/src/jit/IonAnalysis.cpp
+++ b/js/src/jit/IonAnalysis.cpp
@@ -1087,17 +1087,17 @@ TypeAnalyzer::replaceRedundantPhi(MPhi *
         break;
       case MIRType_MagicOptimizedArguments:
         v = MagicValue(JS_OPTIMIZED_ARGUMENTS);
         break;
       case MIRType_MagicOptimizedOut:
         v = MagicValue(JS_OPTIMIZED_OUT);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected type");
+        MOZ_CRASH("unexpected type");
     }
     MConstant *c = MConstant::New(alloc(), v);
     // The instruction pass will insert the box
     block->insertBefore(*(block->begin()), c);
     phi->replaceAllUsesWith(c);
 }
 
 bool
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -1365,28 +1365,28 @@ IonBuilder::snoopControlFlow(JSOp op)
           case SRC_WHILE:
           case SRC_FOR_IN:
           case SRC_FOR_OF:
             // while (cond) { }
             return whileOrForInLoop(sn);
 
           default:
             // Hard assert for now - make an error later.
-            MOZ_ASSUME_UNREACHABLE("unknown goto case");
+            MOZ_CRASH("unknown goto case");
         }
         break;
       }
 
       case JSOP_TABLESWITCH:
         return tableSwitch(op, info().getNote(gsn, pc));
 
       case JSOP_IFNE:
         // We should never reach an IFNE, it's a stopAt point, which will
         // trigger closing the loop.
-        MOZ_ASSUME_UNREACHABLE("we should never reach an ifne!");
+        MOZ_CRASH("we should never reach an ifne!");
 
       default:
         break;
     }
     return ControlStatus_None;
 }
 
 bool
@@ -1656,17 +1656,17 @@ IonBuilder::inspectOpcode(JSOp op)
       case JSOP_UINT24:
         return pushConstant(Int32Value(GET_UINT24(pc)));
 
       case JSOP_INT32:
         return pushConstant(Int32Value(GET_INT32(pc)));
 
       case JSOP_LOOPHEAD:
         // JSOP_LOOPHEAD is handled when processing the loop header.
-        MOZ_ASSUME_UNREACHABLE("JSOP_LOOPHEAD outside loop");
+        MOZ_CRASH("JSOP_LOOPHEAD outside loop");
 
       case JSOP_GETELEM:
       case JSOP_CALLELEM:
         return jsop_getelem();
 
       case JSOP_SETELEM:
         return jsop_setelem();
 
@@ -1868,17 +1868,17 @@ IonBuilder::processCfgEntry(CFGState &st
 
       case CFGState::LABEL:
         return processLabelEnd(state);
 
       case CFGState::TRY:
         return processTryEnd(state);
 
       default:
-        MOZ_ASSUME_UNREACHABLE("unknown cfgstate");
+        MOZ_CRASH("unknown cfgstate");
     }
 }
 
 IonBuilder::ControlStatus
 IonBuilder::processIfEnd(CFGState &state)
 {
     if (current) {
         // Here, the false block is the join point. Create an edge from the
@@ -2576,17 +2576,17 @@ IonBuilder::processSwitchBreak(JSOp op)
     switch (state.state) {
       case CFGState::TABLE_SWITCH:
         breaks = &state.tableswitch.breaks;
         break;
       case CFGState::COND_SWITCH_BODY:
         breaks = &state.condswitch.breaks;
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Unexpected switch state.");
+        MOZ_CRASH("Unexpected switch state.");
     }
 
     *breaks = new(alloc()) DeferredEdge(current, *breaks);
 
     setCurrent(nullptr);
     pc += js_CodeSpec[op].length;
     return processControlEnd();
 }
@@ -2655,17 +2655,17 @@ IonBuilder::maybeLoop(JSOp op, jssrcnote
 
             // for (; ; update?)
             if (SN_TYPE(sn) == SRC_FOR)
                 return forLoop(op, sn);
         }
         break;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected opcode");
+        MOZ_CRASH("unexpected opcode");
     }
 
     return ControlStatus_None;
 }
 
 void
 IonBuilder::assertValidLoopHeadOp(jsbytecode *pc)
 {
@@ -2685,17 +2685,17 @@ IonBuilder::assertValidLoopHeadOp(jsbyte
 
         jsbytecode *expected_ifne;
         switch (state.state) {
           case CFGState::DO_WHILE_LOOP_BODY:
             expected_ifne = state.loop.updateEnd;
             break;
 
           default:
-            MOZ_ASSUME_UNREACHABLE("JSOP_LOOPHEAD unexpected source note");
+            MOZ_CRASH("JSOP_LOOPHEAD unexpected source note");
         }
 
         // Make sure this loop goes to the same ifne as the loop header's
         // source notes or GOTO.
         JS_ASSERT(ifne == expected_ifne);
     } else {
         JS_ASSERT(state.state != CFGState::DO_WHILE_LOOP_BODY);
     }
@@ -3582,17 +3582,17 @@ IonBuilder::jsop_ifeq(JSOp op)
         JS_ASSERT(falseEnd >= falseStart);
 
         if (!cfgStack_.append(CFGState::IfElse(trueEnd, falseEnd, test)))
             return false;
         break;
       }
 
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected source note type");
+        MOZ_CRASH("unexpected source note type");
     }
 
     // Switch to parsing the true branch. Note that no PC update is needed,
     // it's the next instruction.
     if (!setCurrentAndSpecializePhis(ifTrue))
         return false;
 
     // Filter the types in the true branch.
@@ -3704,17 +3704,17 @@ IonBuilder::processReturn(JSOp op)
             break;
         }
 
         def = current->getSlot(info().returnValueSlot());
         break;
 
       default:
         def = nullptr;
-        MOZ_ASSUME_UNREACHABLE("unknown return op");
+        MOZ_CRASH("unknown return op");
     }
 
     if (instrumentedProfiling() && inliningDepth_ == 0) {
         current->add(MProfilerStackOp::New(alloc(), script(), MProfilerStackOp::Exit));
     }
     MReturn *ret = MReturn::New(alloc(), def);
     current->end(ret);
 
@@ -3823,17 +3823,17 @@ IonBuilder::jsop_bitop(JSOp op)
         ins = MRsh::New(alloc(), left, right);
         break;
 
       case JSOP_URSH:
         ins = MUrsh::New(alloc(), left, right);
         break;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected bitop");
+        MOZ_CRASH("unexpected bitop");
     }
 
     current->add(ins);
     ins->infer(inspector, pc);
 
     current->push(ins);
     if (ins->isEffectful() && !resumeAfter(ins))
         return false;
@@ -3880,17 +3880,17 @@ IonBuilder::jsop_binary(JSOp op, MDefini
         ins = MDiv::New(alloc(), left, right);
         break;
 
       case JSOP_MOD:
         ins = MMod::New(alloc(), left, right);
         break;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected binary opcode");
+        MOZ_CRASH("unexpected binary opcode");
     }
 
     current->add(ins);
     ins->infer(alloc(), inspector, pc);
     current->push(ins);
 
     if (ins->isEffectful())
         return resumeAfter(ins);
@@ -4227,17 +4227,17 @@ IonBuilder::selectInliningTargets(Object
             return false;
           case InliningDecision_DontInline:
             inlineable = false;
             break;
           case InliningDecision_Inline:
             inlineable = true;
             break;
           default:
-            MOZ_ASSUME_UNREACHABLE("Unhandled InliningDecision value!");
+            MOZ_CRASH("Unhandled InliningDecision value!");
         }
 
         // Enforce a maximum inlined bytecode limit at the callsite.
         if (inlineable && target->isInterpreted()) {
             totalSize += target->nonLazyScript()->length();
             if (totalSize > optimizationInfo().inlineMaxTotalBytecodeLength())
                 inlineable = false;
         }
@@ -6605,17 +6605,17 @@ jit::TypeSetIncludes(types::TypeSet *typ
 
       case MIRType_Object:
         return types->unknownObject() || (inputTypes && inputTypes->isSubset(types));
 
       case MIRType_Value:
         return types->unknown() || (inputTypes && inputTypes->isSubset(types));
 
       default:
-        MOZ_ASSUME_UNREACHABLE("Bad input type");
+        MOZ_CRASH("Bad input type");
     }
 }
 
 // Whether a write of the given value may need a post-write barrier for GC purposes.
 bool
 jit::NeedsPostBarrier(CompileInfo &info, MDefinition *value)
 {
 #ifdef JSGC_GENERATIONAL
@@ -6889,20 +6889,20 @@ IonBuilder::getElemTryTypedObject(bool *
                                                  objPrediction,
                                                  elemPrediction,
                                                  elemSize);
 
       case type::Reference:
         return true;
 
       case type::UnsizedArray:
-        MOZ_ASSUME_UNREACHABLE("Unsized arrays cannot be element types");
-    }
-
-    MOZ_ASSUME_UNREACHABLE("Bad kind");
+        MOZ_CRASH("Unsized arrays cannot be element types");
+    }
+
+    MOZ_CRASH("Bad kind");
 }
 
 static MIRType
 MIRTypeForTypedArrayRead(Scalar::Type arrayType, bool observedDouble);
 
 bool
 IonBuilder::checkTypedObjectIndexInBounds(int32_t elemSize,
                                           MDefinition *obj,
@@ -7634,17 +7634,17 @@ MIRTypeForTypedArrayRead(Scalar::Type ar
         return observedDouble ? MIRType_Double : MIRType_Int32;
       case Scalar::Float32:
         return MIRType_Float32;
       case Scalar::Float64:
         return MIRType_Double;
       default:
         break;
     }
-    MOZ_ASSUME_UNREACHABLE("Unknown typed array type");
+    MOZ_CRASH("Unknown typed array type");
 }
 
 bool
 IonBuilder::jsop_getelem_typed(MDefinition *obj, MDefinition *index,
                                Scalar::Type arrayType)
 {
     types::TemporaryTypeSet *types = bytecodeTypes(pc);
 
@@ -7702,17 +7702,17 @@ IonBuilder::jsop_getelem_typed(MDefiniti
                 barrier = BarrierKind::NoBarrier;
             break;
           case Scalar::Float32:
           case Scalar::Float64:
             if (allowDouble)
                 barrier = BarrierKind::NoBarrier;
             break;
           default:
-            MOZ_ASSUME_UNREACHABLE("Unknown typed array type");
+            MOZ_CRASH("Unknown typed array type");
         }
 
         // Assume we will read out-of-bound values. In this case the
         // bounds check will be part of the instruction, and the instruction
         // will always return a Value.
         MLoadTypedArrayElementHole *load =
             MLoadTypedArrayElementHole::New(alloc(), obj, index, arrayType, allowDouble);
         current->add(load);
@@ -7800,17 +7800,17 @@ IonBuilder::setElemTryTypedObject(bool *
                                                  obj,
                                                  index,
                                                  objPrediction,
                                                  value,
                                                  elemPrediction,
                                                  elemSize);
     }
 
-    MOZ_ASSUME_UNREACHABLE("Bad kind");
+    MOZ_CRASH("Bad kind");
 }
 
 bool
 IonBuilder::setElemTryScalarElemOfTypedObject(bool *emitted,
                                               MDefinition *obj,
                                               MDefinition *index,
                                               TypedObjectPrediction objPrediction,
                                               MDefinition *value,
@@ -8069,17 +8069,17 @@ IonBuilder::jsop_setelem_dense(types::Te
         newValue = maybeDouble;
         break;
       }
 
       case types::TemporaryTypeSet::DontConvertToDoubles:
         break;
 
       default:
-        MOZ_ASSUME_UNREACHABLE("Unknown double conversion");
+        MOZ_CRASH("Unknown double conversion");
     }
 
     bool writeHole = false;
     if (safety == SetElem_Normal) {
         SetElemICInspector icInspect(inspector->setElemICInspector(pc));
         writeHole = icInspect.sawOOBDenseWrite();
     }
 
@@ -8880,20 +8880,20 @@ IonBuilder::getPropTryTypedObject(bool *
       case type::Scalar:
         return getPropTryScalarPropOfTypedObject(emitted,
                                                  obj,
                                                  fieldOffset,
                                                  fieldPrediction,
                                                  resultTypes);
 
       case type::UnsizedArray:
-        MOZ_ASSUME_UNREACHABLE("Field of unsized array type");
-    }
-
-    MOZ_ASSUME_UNREACHABLE("Bad kind");
+        MOZ_CRASH("Field of unsized array type");
+    }
+
+    MOZ_CRASH("Bad kind");
 }
 
 bool
 IonBuilder::getPropTryScalarPropOfTypedObject(bool *emitted, MDefinition *typedObj,
                                               int32_t fieldOffset,
                                               TypedObjectPrediction fieldPrediction,
                                               types::TemporaryTypeSet *resultTypes)
 {
@@ -9530,17 +9530,17 @@ IonBuilder::setPropTryTypedObject(bool *
         // For now, only optimize storing scalars.
         return true;
 
       case type::Scalar:
         return setPropTryScalarPropOfTypedObject(emitted, obj, fieldOffset,
                                                  value, fieldPrediction);
     }
 
-    MOZ_ASSUME_UNREACHABLE("Unknown kind");
+    MOZ_CRASH("Unknown kind");
 }
 
 bool
 IonBuilder::setPropTryScalarPropOfTypedObject(bool *emitted,
                                               MDefinition *obj,
                                               int32_t fieldOffset,
                                               MDefinition *value,
                                               TypedObjectPrediction fieldPrediction)
--- a/js/src/jit/IonCaches.cpp
+++ b/js/src/jit/IonCaches.cpp
@@ -1270,17 +1270,17 @@ GetPropertyIC::tryAttachNative(JSContext
         break;
       case CanAttachArrayLength:
         if (!GenerateArrayLength(cx, masm, attacher, obj, object(), output()))
             return false;
 
         attachKind = "array length";
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Bad NativeGetPropCacheability");
+        MOZ_CRASH("Bad NativeGetPropCacheability");
     }
     return linkAndAttachStub(cx, masm, attacher, ion, attachKind);
 }
 
 bool
 GetPropertyIC::tryAttachTypedArrayLength(JSContext *cx, HandleScript outerScript, IonScript *ion,
                                          HandleObject obj, HandlePropertyName name, bool *emitted)
 {
@@ -4180,17 +4180,17 @@ IsCacheableNonGlobalScopeChain(JSObject 
 
         scopeChain = &scopeChain->as<ScopeObject>().enclosingScope();
         if (!scopeChain) {
             IonSpew(IonSpew_InlineCaches, "Scope chain indirect hit");
             return false;
         }
     }
 
-    MOZ_ASSUME_UNREACHABLE("Invalid scope chain");
+    MOZ_CRASH("Invalid scope chain");
 }
 
 JSObject *
 BindNameIC::update(JSContext *cx, size_t cacheIndex, HandleObject scopeChain)
 {
     RootedScript outerScript(cx, GetTopIonJSScript(cx));
     IonScript *ion = outerScript->ionScript();
     BindNameIC &cache = ion->getCache(cacheIndex).toBindName();
--- a/js/src/jit/IonCaches.h
+++ b/js/src/jit/IonCaches.h
@@ -42,17 +42,17 @@ namespace jit {
 IONCACHE_KIND_LIST(FORWARD_DECLARE)
 #undef FORWARD_DECLARE
 
 class IonCacheVisitor
 {
   public:
 #define VISIT_INS(op)                                               \
     virtual bool visit##op##IC(CodeGenerator *codegen) {            \
-        MOZ_ASSUME_UNREACHABLE("NYI: " #op "IC");                   \
+        MOZ_CRASH("NYI: " #op "IC");                                \
     }
 
     IONCACHE_KIND_LIST(VISIT_INS)
 #undef VISIT_INS
 };
 
 // Common shared temporary state needed during codegen between the different
 // kinds of caches. Used by OutOfLineUpdateCache.
--- a/js/src/jit/IonFrames.cpp
+++ b/js/src/jit/IonFrames.cpp
@@ -279,17 +279,17 @@ SizeOfFramePrefix(FrameType type)
         return IonBaselineStubFrameLayout::Size();
       case JitFrame_Rectifier:
         return IonRectifierFrameLayout::Size();
       case JitFrame_Unwound_Rectifier:
         return IonUnwoundRectifierFrameLayout::Size();
       case JitFrame_Exit:
         return IonExitFrameLayout::Size();
       default:
-        MOZ_ASSUME_UNREACHABLE("unknown frame type");
+        MOZ_CRASH("unknown frame type");
     }
 }
 
 uint8_t *
 JitFrameIterator::prevFp() const
 {
     size_t currentSize = SizeOfFramePrefix(type_);
     // This quick fix must be removed as soon as bug 717297 land.  This is
@@ -462,17 +462,17 @@ HandleExceptionIon(JSContext *cx, const 
                     return;
 
                 // Error on bailout clears pending exception.
                 MOZ_ASSERT(!cx->isExceptionPending());
             }
             break;
 
           default:
-            MOZ_ASSUME_UNREACHABLE("Unexpected try note");
+            MOZ_CRASH("Unexpected try note");
         }
     }
 }
 
 static void
 ForcedReturn(JSContext *cx, const JitFrameIterator &frame, jsbytecode *pc,
              ResumeFromException *rfe, bool *calledDebugEpilogue)
 {
@@ -523,17 +523,17 @@ HandleExceptionBaseline(JSContext *cx, c
             JS_ASSERT(cx->isExceptionPending());
             break;
 
           case JSTRAP_RETURN:
             ForcedReturn(cx, frame, pc, rfe, calledDebugEpilogue);
             return;
 
           default:
-            MOZ_ASSUME_UNREACHABLE("Invalid trap status");
+            MOZ_CRASH("Invalid trap status");
         }
     }
 
     if (!script->hasTrynotes())
         return;
 
     JSTryNote *tn = script->trynotes()->vector;
     JSTryNote *tnEnd = tn + script->trynotes()->length;
@@ -602,17 +602,17 @@ HandleExceptionBaseline(JSContext *cx, c
                 UnwindIteratorForUncatchableException(cx, iterObject);
             break;
           }
 
           case JSTRY_LOOP:
             break;
 
           default:
-            MOZ_ASSUME_UNREACHABLE("Invalid try note");
+            MOZ_CRASH("Invalid try note");
         }
     }
 
 }
 
 struct AutoDeleteDebugModeOSRInfo
 {
     BaselineFrame *frame;
@@ -837,17 +837,17 @@ MarkCalleeToken(JSTracer *trc, CalleeTok
       }
       case CalleeToken_Script:
       {
         JSScript *script = CalleeTokenToScript(token);
         MarkScriptRoot(trc, &script, "ion-entry");
         return CalleeToToken(script);
       }
       default:
-        MOZ_ASSUME_UNREACHABLE("unknown callee token type");
+        MOZ_CRASH("unknown callee token type");
     }
 }
 
 #ifdef JS_NUNBOX32
 static inline uintptr_t
 ReadAllocation(const JitFrameIterator &frame, const LAllocation *a)
 {
     if (a->isGeneralReg()) {
@@ -1041,17 +1041,17 @@ JitActivationIterator::jitStackRange(uin
         min = reinterpret_cast<uintptr_t *>(frames.fp());
     } else {
         IonExitFrameLayout *exitFrame = frames.exitFrame();
         IonExitFooterFrame *footer = exitFrame->footer();
         const VMFunction *f = footer->function();
         if (exitFrame->isWrapperExit() && f->outParam == Type_Handle) {
             switch (f->outParamRootType) {
               case VMFunction::RootNone:
-                MOZ_ASSUME_UNREACHABLE("Handle outparam must have root type");
+                MOZ_CRASH("Handle outparam must have root type");
               case VMFunction::RootObject:
               case VMFunction::RootString:
               case VMFunction::RootPropertyName:
               case VMFunction::RootFunction:
               case VMFunction::RootCell:
                 // These are all handles to GCThing pointers.
                 min = reinterpret_cast<uintptr_t *>(footer->outParam<void *>());
                 break;
@@ -1229,17 +1229,17 @@ MarkJitExitFrame(JSTracer *trc, const Ji
             argBase += 2 * sizeof(void *);
             break;
         }
     }
 
     if (f->outParam == Type_Handle) {
         switch (f->outParamRootType) {
           case VMFunction::RootNone:
-            MOZ_ASSUME_UNREACHABLE("Handle outparam must have root type");
+            MOZ_CRASH("Handle outparam must have root type");
           case VMFunction::RootObject:
             gc::MarkObjectRoot(trc, footer->outParam<JSObject *>(), "ion-vm-out");
             break;
           case VMFunction::RootString:
           case VMFunction::RootPropertyName:
             gc::MarkStringRoot(trc, footer->outParam<JSString *>(), "ion-vm-out");
             break;
           case VMFunction::RootFunction:
@@ -1294,24 +1294,24 @@ MarkJitActivation(JSTracer *trc, const J
             break;
           case JitFrame_BaselineStub:
             MarkBaselineStubFrame(trc, frames);
             break;
           case JitFrame_IonJS:
             MarkIonJSFrame(trc, frames);
             break;
           case JitFrame_Unwound_IonJS:
-            MOZ_ASSUME_UNREACHABLE("invalid");
+            MOZ_CRASH("invalid");
           case JitFrame_Rectifier:
             MarkRectifierFrame(trc, frames);
             break;
           case JitFrame_Unwound_Rectifier:
             break;
           default:
-            MOZ_ASSUME_UNREACHABLE("unexpected frame type");
+            MOZ_CRASH("unexpected frame type");
         }
     }
 }
 
 void
 MarkJitActivations(PerThreadData *ptd, JSTracer *trc)
 {
     for (JitActivationIterator activations(ptd); !activations.done(); ++activations)
@@ -1516,17 +1516,17 @@ FromTypedPayload(JSValueType type, uintp
         return BooleanValue(!!payload);
       case JSVAL_TYPE_STRING:
         return FromStringPayload(payload);
       case JSVAL_TYPE_SYMBOL:
         return FromSymbolPayload(payload);
       case JSVAL_TYPE_OBJECT:
         return FromObjectPayload(payload);
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected type - needs payload");
+        MOZ_CRASH("unexpected type - needs payload");
     }
 }
 
 bool
 SnapshotIterator::allocationReadable(const RValueAllocation &alloc)
 {
     switch (alloc.mode()) {
       case RValueAllocation::DOUBLE_REG:
@@ -1604,17 +1604,17 @@ SnapshotIterator::allocationValue(const 
             return BooleanValue(ReadFrameBooleanSlot(fp_, alloc.stackOffset2()));
           case JSVAL_TYPE_STRING:
             return FromStringPayload(fromStack(alloc.stackOffset2()));
           case JSVAL_TYPE_SYMBOL:
             return FromSymbolPayload(fromStack(alloc.stackOffset2()));
           case JSVAL_TYPE_OBJECT:
             return FromObjectPayload(fromStack(alloc.stackOffset2()));
           default:
-            MOZ_ASSUME_UNREACHABLE("Unexpected type");
+            MOZ_CRASH("Unexpected type");
         }
       }
 
 #if defined(JS_NUNBOX32)
       case RValueAllocation::UNTYPED_REG_REG:
       {
         jsval_layout layout;
         layout.s.tag = (JSValueTag) fromRegister(alloc.reg());
@@ -1660,17 +1660,17 @@ SnapshotIterator::allocationValue(const 
         return IMPL_TO_JSVAL(layout);
       }
 #endif
 
       case RValueAllocation::RECOVER_INSTRUCTION:
         return fromInstructionResult(alloc.index());
 
       default:
-        MOZ_ASSUME_UNREACHABLE("huh?");
+        MOZ_CRASH("huh?");
     }
 }
 
 const RResumePoint *
 SnapshotIterator::resumePoint() const
 {
     return instruction()->toResumePoint();
 }
@@ -1771,20 +1771,20 @@ JitFrameIterator::ionScriptFromCalleeTok
       case CalleeToken_Function:
       case CalleeToken_Script:
         switch (mode_) {
           case SequentialExecution:
             return script()->ionScript();
           case ParallelExecution:
             return script()->parallelIonScript();
           default:
-            MOZ_ASSUME_UNREACHABLE("No such execution mode");
+            MOZ_CRASH("No such execution mode");
         }
       default:
-        MOZ_ASSUME_UNREACHABLE("unknown callee token type");
+        MOZ_CRASH("unknown callee token type");
     }
 }
 
 const SafepointIndex *
 JitFrameIterator::safepoint() const
 {
     if (!cachedSafepointIndex_)
         cachedSafepointIndex_ = ionScript()->getSafepointIndex(returnAddressToFp());
--- a/js/src/jit/IonFrames.h
+++ b/js/src/jit/IonFrames.h
@@ -64,17 +64,17 @@ static inline JSScript *
 ScriptFromCalleeToken(CalleeToken token)
 {
     switch (GetCalleeTokenTag(token)) {
       case CalleeToken_Script:
         return CalleeTokenToScript(token);
       case CalleeToken_Function:
         return CalleeTokenToFunction(token)->nonLazyScript();
     }
-    MOZ_ASSUME_UNREACHABLE("invalid callee token tag");
+    MOZ_CRASH("invalid callee token tag");
 }
 
 // In between every two frames lies a small header describing both frames. This
 // header, minimally, contains a returnAddress word and a descriptor word. The
 // descriptor describes the size and type of the previous frame, whereas the
 // returnAddress describes the address the newer frame (the callee) will return
 // to. The exact mechanism in which frames are laid out is architecture
 // dependent.
--- a/js/src/jit/IonMacroAssembler.cpp
+++ b/js/src/jit/IonMacroAssembler.cpp
@@ -283,17 +283,17 @@ StoreToTypedFloatArray(MacroAssembler &m
       case Scalar::Float64:
 #ifdef JS_MORE_DETERMINISTIC
         // See the comment in TypedArrayObjectTemplate::doubleToNative.
         masm.canonicalizeDouble(value);
 #endif
         masm.storeDouble(value, dest);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
+        MOZ_CRASH("Invalid typed array type");
     }
 }
 
 void
 MacroAssembler::storeToTypedFloatArray(Scalar::Type arrayType, FloatRegister value,
                                        const BaseIndex &dest)
 {
     StoreToTypedFloatArray(*this, arrayType, value, dest);
@@ -344,17 +344,17 @@ MacroAssembler::loadFromTypedArray(Scala
         loadFloat32(src, dest.fpu());
         canonicalizeFloat(dest.fpu());
         break;
       case Scalar::Float64:
         loadDouble(src, dest.fpu());
         canonicalizeDouble(dest.fpu());
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
+        MOZ_CRASH("Invalid typed array type");
     }
 }
 
 template void MacroAssembler::loadFromTypedArray(Scalar::Type arrayType, const Address &src, AnyRegister dest,
                                                  Register temp, Label *fail);
 template void MacroAssembler::loadFromTypedArray(Scalar::Type arrayType, const BaseIndex &src, AnyRegister dest,
                                                  Register temp, Label *fail);
 
@@ -404,17 +404,17 @@ MacroAssembler::loadFromTypedArray(Scala
         boxDouble(ScratchDoubleReg, dest);
         break;
       case Scalar::Float64:
         loadFromTypedArray(arrayType, src, AnyRegister(ScratchDoubleReg), dest.scratchReg(),
                            nullptr);
         boxDouble(ScratchDoubleReg, dest);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
+        MOZ_CRASH("Invalid typed array type");
     }
 }
 
 template void MacroAssembler::loadFromTypedArray(Scalar::Type arrayType, const Address &src, const ValueOperand &dest,
                                                  bool allowDouble, Register temp, Label *fail);
 template void MacroAssembler::loadFromTypedArray(Scalar::Type arrayType, const BaseIndex &src, const ValueOperand &dest,
                                                  bool allowDouble, Register temp, Label *fail);
 
@@ -1236,17 +1236,17 @@ MacroAssembler::loadContext(Register cxR
       case SequentialExecution:
         // The scratch register is not used for sequential execution.
         loadJSContext(cxReg);
         break;
       case ParallelExecution:
         loadForkJoinContext(cxReg, scratch);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("No such execution mode");
+        MOZ_CRASH("No such execution mode");
     }
 }
 
 void
 MacroAssembler::enterParallelExitFrameAndLoadContext(const VMFunction *f, Register cx,
                                                      Register scratch)
 {
     loadForkJoinContext(cx, scratch);
@@ -1279,17 +1279,17 @@ MacroAssembler::enterExitFrameAndLoadCon
         // The scratch register is not used for sequential execution.
         enterExitFrame(f);
         loadJSContext(cxReg);
         break;
       case ParallelExecution:
         enterParallelExitFrameAndLoadContext(f, cxReg, scratch);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("No such execution mode");
+        MOZ_CRASH("No such execution mode");
     }
 }
 
 void
 MacroAssembler::enterFakeExitFrame(Register cxReg, Register scratch,
                                    ExecutionMode executionMode,
                                    JitCode *codeVal)
 {
@@ -1297,17 +1297,17 @@ MacroAssembler::enterFakeExitFrame(Regis
       case SequentialExecution:
         // The cx and scratch registers are not used for sequential execution.
         enterFakeExitFrame(codeVal);
         break;
       case ParallelExecution:
         enterFakeParallelExitFrame(cxReg, scratch, codeVal);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("No such execution mode");
+        MOZ_CRASH("No such execution mode");
     }
 }
 
 void
 MacroAssembler::handleFailure(ExecutionMode executionMode)
 {
     // Re-entry code is irrelevant because the exception will leave the
     // running function and never come back
@@ -1319,17 +1319,17 @@ MacroAssembler::handleFailure(ExecutionM
     switch (executionMode) {
       case SequentialExecution:
         handler = JS_FUNC_TO_DATA_PTR(void *, jit::HandleException);
         break;
       case ParallelExecution:
         handler = JS_FUNC_TO_DATA_PTR(void *, jit::HandleParallelFailure);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("No such execution mode");
+        MOZ_CRASH("No such execution mode");
     }
     MacroAssemblerSpecific::handleFailureWithHandler(handler);
 
     // Doesn't actually emit code, but balances the leave()
     if (sps_)
         sps_->reenter(*this, InvalidReg);
 }
 
@@ -1617,17 +1617,17 @@ MacroAssembler::convertValueToFloatingPo
     return true;
 }
 
 void
 MacroAssembler::PushEmptyRooted(VMFunction::RootType rootType)
 {
     switch (rootType) {
       case VMFunction::RootNone:
-        MOZ_ASSUME_UNREACHABLE("Handle must have root type");
+        MOZ_CRASH("Handle must have root type");
       case VMFunction::RootObject:
       case VMFunction::RootString:
       case VMFunction::RootPropertyName:
       case VMFunction::RootFunction:
       case VMFunction::RootCell:
         Push(ImmPtr(nullptr));
         break;
       case VMFunction::RootValue:
@@ -1637,17 +1637,17 @@ MacroAssembler::PushEmptyRooted(VMFuncti
 }
 
 void
 MacroAssembler::popRooted(VMFunction::RootType rootType, Register cellReg,
                           const ValueOperand &valueReg)
 {
     switch (rootType) {
       case VMFunction::RootNone:
-        MOZ_ASSUME_UNREACHABLE("Handle must have root type");
+        MOZ_CRASH("Handle must have root type");
       case VMFunction::RootObject:
       case VMFunction::RootString:
       case VMFunction::RootPropertyName:
       case VMFunction::RootFunction:
       case VMFunction::RootCell:
         Pop(cellReg);
         break;
       case VMFunction::RootValue:
@@ -1708,17 +1708,17 @@ MacroAssembler::convertTypedOrValueToFlo
       case MIRType_String:
       case MIRType_Symbol:
         jump(fail);
         break;
       case MIRType_Undefined:
         loadConstantFloatingPoint(GenericNaN(), float(GenericNaN()), output, outputType);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Bad MIRType");
+        MOZ_CRASH("Bad MIRType");
     }
 }
 
 void
 MacroAssembler::convertDoubleToInt(FloatRegister src, Register output, FloatRegister temp,
                                    Label *truncateFail, Label *fail,
                                    IntConversionBehavior behavior)
 {
@@ -1923,17 +1923,17 @@ MacroAssembler::convertTypedOrValueToInt
         convertDoubleToInt(temp, output, temp, nullptr, fail, behavior);
         break;
       case MIRType_String:
       case MIRType_Symbol:
       case MIRType_Object:
         jump(fail);
         break;
       default:
-        MOZ_ASSUME_UNREACHABLE("Bad MIRType");
+        MOZ_CRASH("Bad MIRType");
     }
 }
 
 void
 MacroAssembler::finish()
 {
     if (sequentialFailureLabel_.used()) {
         bind(&sequentialFailureLabel_);
@@ -2011,17 +2011,17 @@ MacroAssembler::branchEqualTypeIfNeeded(
             break;
           case MIRType_Symbol:
             branchTestSymbol(Equal, tag, label);
             break;
           case MIRType_Object:
             branchTestObject(Equal, tag, label);
             break;
           default:
-            MOZ_ASSUME_UNREACHABLE("Unsupported type");
+            MOZ_CRASH("Unsupported type");
         }
     }
 }
 
 
 // If a pseudostack frame has this as its label, its stack pointer
 // field points to the registers saved on entry to JIT code.  A native
 // stack unwinder could use that information to continue unwinding
--- a/js/src/jit/IonMacroAssembler.h
+++ b/js/src/jit/IonMacroAssembler.h
@@ -140,17 +140,17 @@ class MacroAssembler : public MacroAssem
             if (type_.isPrimitive()) {
                 if (type_.isMagicArguments())
                     mirType = MIRType_MagicOptimizedArguments;
                 else
                     mirType = MIRTypeFromValueType(type_.primitive());
             } else if (type_.isAnyObject()) {
                 mirType = MIRType_Object;
             } else {
-                MOZ_ASSUME_UNREACHABLE("Unknown conversion to mirtype");
+                MOZ_CRASH("Unknown conversion to mirtype");
             }
 
             if (mirType == MIRType_Double)
                 masm.branchTestNumber(cond(), reg(), jump());
             else
                 masm.branchTestMIRType(cond(), reg(), mirType, jump());
         }
 
@@ -342,17 +342,17 @@ class MacroAssembler : public MacroAssem
           case MIRType_String:    return branchTestString(cond, val, label);
           case MIRType_Symbol:    return branchTestSymbol(cond, val, label);
           case MIRType_Object:    return branchTestObject(cond, val, label);
           case MIRType_Double:    return branchTestDouble(cond, val, label);
           case MIRType_MagicOptimizedArguments: // Fall through.
           case MIRType_MagicIsConstructing:
           case MIRType_MagicHole: return branchTestMagic(cond, val, label);
           default:
-            MOZ_ASSUME_UNREACHABLE("Bad MIRType");
+            MOZ_CRASH("Bad MIRType");
         }
     }
 
     // Branches to |label| if |reg| is false. |reg| should be a C++ bool.
     void branchIfFalseBool(Register reg, Label *label) {
         // Note that C++ bool is only 1 byte, so ignore the higher-order bits.
         branchTest32(Assembler::Zero, reg, Imm32(0xFF), label);
     }
@@ -726,17 +726,17 @@ class MacroAssembler : public MacroAssem
           case Scalar::Uint16:
             store16(value, dest);
             break;
           case Scalar::Int32:
           case Scalar::Uint32:
             store32(value, dest);
             break;
           default:
-            MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
+            MOZ_CRASH("Invalid typed array type");
         }
     }
 
     void storeToTypedFloatArray(Scalar::Type arrayType, FloatRegister value, const BaseIndex &dest);
     void storeToTypedFloatArray(Scalar::Type arrayType, FloatRegister value, const Address &dest);
 
     Register extractString(const Address &address, Register scratch) {
         return extractObject(address, scratch);
@@ -1154,17 +1154,17 @@ class MacroAssembler : public MacroAssem
         // Exceptions are currently handled the same way as sequential failures.
         return &sequentialFailureLabel_;
     }
 
     Label *failureLabel(ExecutionMode executionMode) {
         switch (executionMode) {
           case SequentialExecution: return &sequentialFailureLabel_;
           case ParallelExecution: return &parallelFailureLabel_;
-          default: MOZ_ASSUME_UNREACHABLE("Unexpected execution mode");
+          default: MOZ_CRASH("Unexpected execution mode");
         }
     }
 
     void finish();
 
     void assumeUnreachable(const char *output);
     void printf(const char *output);
     void printf(const char *output, Register value);
@@ -1451,17 +1451,17 @@ JSOpToDoubleCondition(JSOp op)
         return Assembler::DoubleLessThan;
       case JSOP_LE:
         return Assembler::DoubleLessThanOrEqual;
       case JSOP_GT:
         return Assembler::DoubleGreaterThan;
       case JSOP_GE:
         return Assembler::DoubleGreaterThanOrEqual;
       default:
-        MOZ_ASSUME_UNREACHABLE("Unexpected comparison operation");
+        MOZ_CRASH("Unexpected comparison operation");
     }
 }
 
 // Note: the op may have been inverted during lowering (to put constants in a
 // position where they can be immediates), so it is important to use the
 // lir->jsop() instead of the mir->jsop() when it is present.
 static inline Assembler::Condition
 JSOpToCondition(JSOp op, bool isSigned)
@@ -1478,17 +1478,17 @@ JSOpToCondition(JSOp op, bool isSigned)
             return Assembler::LessThan;
           case JSOP_LE:
             return Assembler::LessThanOrEqual;
           case JSOP_GT:
             return Assembler::GreaterThan;
           case JSOP_GE:
             return Assembler::GreaterThanOrEqual;
           default:
-            MOZ_ASSUME_UNREACHABLE("Unrecognized comparison operation");
+            MOZ_CRASH("Unrecognized comparison operation");
         }
     } else {
         switch (op) {
           case JSOP_EQ:
           case JSOP_STRICTEQ:
             return Assembler::Equal;
           case JSOP_NE:
           case JSOP_STRICTNE:
@@ -1497,17 +1497,17 @@ JSOpToCondition(JSOp op, bool isSigned)
             return Assembler::Below;
           case JSOP_LE:
             return Assembler::BelowOrEqual;
           case JSOP_GT:
             return Assembler::Above;
           case JSOP_GE:
             return Assembler::AboveOrEqual;
           default:
-            MOZ_ASSUME_UNREACHABLE("Unrecognized comparison operation");
+            MOZ_CRASH("Unrecognized comparison operation");
         }
     }
 }
 
 static inline size_t
 StackDecrementForCall(size_t bytesAlreadyPushed, size_t bytesToPush)
 {
     return bytesToPush +
--- a/js/src/jit/IonOptimizationLevels.cpp
+++ b/js/src/jit/IonOptimizationLevels.cpp
@@ -115,17 +115,17 @@ OptimizationInfos::OptimizationInfos()
 OptimizationLevel
 OptimizationInfos::nextLevel(OptimizationLevel level) const
 {
     JS_ASSERT(!isLastLevel(level));
     switch (level) {
       case Optimization_DontCompile:
         return Optimization_Normal;
       default:
-        MOZ_ASSUME_UNREACHABLE("Unknown optimization level.");
+        MOZ_CRASH("Unknown optimization level.");
     }
 }
 
 OptimizationLevel
 OptimizationInfos::firstLevel() const
 {
     return nextLevel(Optimization_DontCompile);
 }
--- a/js/src/jit/IonOptimizationLevels.h
+++ b/js/src/jit/IonOptimizationLevels.h
@@ -31,17 +31,17 @@ OptimizationLevelString(OptimizationLeve
     switch (level) {
       case Optimization_DontCompile:
         return "Optimization_DontCompile";
       case Optimization_Normal:
         return "Optimization_Normal";
       case Optimization_AsmJS:
         return "Optimization_AsmJS";
       default:
-        MOZ_ASSUME_UNREACHABLE("Invalid OptimizationLevel");
+        MOZ_CRASH("Invalid OptimizationLevel");
     }
 }
 #endif
 
 class OptimizationInfo
 {
   public:
     OptimizationLevel level_;
--- a/js/src/jit/IonTypes.h
+++ b/js/src/jit/IonTypes.h
@@ -217,17 +217,17 @@ BailoutKindString(BailoutKind kind)
         return "Bailout_BoundsCheck";
       case Bailout_Neutered:
         return "Bailout_Neutered";
       case Bailout_ShapeGuard:
         return "Bailout_ShapeGuard";
       case Bailout_IonExceptionDebugMode:
         return "Bailout_IonExceptionDebugMode";
       default:
-        MOZ_ASSUME_UNREACHABLE("Invalid BailoutKind");
+        MOZ_CRASH("Invalid BailoutKind");
     }
 }
 
 static const uint32_t ELEMENT_TYPE_BITS = 5;
 static const uint32_t ELEMENT_TYPE_SHIFT = 0;
 static const uint32_t ELEMENT_TYPE_MASK = (1 << ELEMENT_TYPE_BITS) - 1;
 static const uint32_t VECTOR_SCALE_BITS = 2;
 static const uint32_t VECTOR_SCALE_SHIFT = ELEMENT_TYPE_BITS + ELEMENT_TYPE_SHIFT;
@@ -403,17 +403,17 @@ MIRTypeFromValueType(JSValueType type)
         return MIRType_Boolean;
       case JSVAL_TYPE_NULL:
         return MIRType_Null;
       case JSVAL_TYPE_OBJECT:
         return MIRType_Object;
       case JSVAL_TYPE_UNKNOWN:
         return MIRType_Value;
       default:
-        MOZ_ASSUME_UNREACHABLE("unexpected jsval type");
+        MOZ_CRASH("unexpected jsval type");
     }
 }
 
 static inline JSValueType
 ValueTypeFromMIRType(MIRType type)
 {
   switch (type) {
     case MIRType_Undefined:
@@ -490,17 +490,17 @@ StringFromMIRType(MIRType type)
       return "Pointer";
     case MIRType_ForkJoinContext:
       return "ForkJoinContext";
     case MIRType_Int32x4:
       return "Int32x4";
     case MIRType_Float32x4:
       return "Float32x4";
     default:
-      MOZ_ASSUME_UNREACHABLE("Unknown MIRType.");
+      MOZ_CRASH("Unknown MIRType.");
   }
 }
 
 static inline bool
 IsNumberType(MIRType type)
 {
     return type == MIRType_Int32 || type == MIRType_Double || type == MIRType_Float32;
 }
@@ -536,31 +536,31 @@ SimdTypeToLength(MIRType type)
 {
     JS_ASSERT(IsSimdType(type));
     switch (type) {
       case MIRType_Int32x4:
       case MIRType_Float32x4:
         return 4;
       default: break;
     }
-    MOZ_ASSUME_UNREACHABLE("unexpected SIMD kind");
+    MOZ_CRASH("unexpected SIMD kind");
 }
 
 static inline MIRType
 SimdTypeToScalarType(MIRType type)
 {
     JS_ASSERT(IsSimdType(type));
     switch (type) {
       case MIRType_Int32x4:
         return MIRType_Int32;
       case MIRType_Float32x4:
         return MIRType_Float32;
       default: break;
     }
-    MOZ_ASSUME_UNREACHABLE("unexpected SIMD kind");
+    MOZ_CRASH("unexpected SIMD kind");
 }
 
 // Indicates a lane in a SIMD register: X for the first lane, Y for the second,
 // Z for the third (if any), W for the fourth (if any).
 enum SimdLane {
     LaneX = 0x0,
     LaneY = 0x1,
     LaneZ = 0x2,