--- a/js/src/jit/IonAnalysis.cpp
+++ b/js/src/jit/IonAnalysis.cpp
@@ -2812,16 +2812,19 @@ TryEliminateBoundsCheck(BoundsCheckMap& 
     // bounds checks and would otherwise use the wrong index and
     // (b) helps register allocation. Note that this is safe since
     // no other pass after bounds check elimination moves instructions.
     dominated->replaceAllUsesWith(dominated->index());
 
     if (!dominated->isMovable())
         return true;
 
+    if (!dominated->fallible())
+        return true;
+
     MBoundsCheck* dominating = FindDominatingBoundsCheck(checks, dominated, blockIndex);
     if (!dominating)
         return false;
 
     if (dominating == dominated) {
         // We didn't find a dominating bounds check.
         return true;
     }

--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -9060,31 +9060,35 @@ class MBoundsCheck
     }
     MDefinition* length() const {
         return getOperand(1);
     }
     int32_t minimum() const {
         return minimum_;
     }
     void setMinimum(int32_t n) {
+        MOZ_ASSERT(fallible_);
         minimum_ = n;
     }
     int32_t maximum() const {
         return maximum_;
     }
     void setMaximum(int32_t n) {
+        MOZ_ASSERT(fallible_);
         maximum_ = n;
     }
     MDefinition* foldsTo(TempAllocator& alloc) override;
     bool congruentTo(const MDefinition* ins) const override {
         if (!ins->isBoundsCheck())
             return false;
         const MBoundsCheck* other = ins->toBoundsCheck();
         if (minimum() != other->minimum() || maximum() != other->maximum())
             return false;
+        if (fallible() != other->fallible())
+            return false;
         return congruentIfOperandsEqual(other);
     }
     virtual AliasSet getAliasSet() const override {
         return AliasSet::None();
     }
     void computeRange(TempAllocator& alloc) override;
     bool fallible() const {
         return fallible_;