Backed out changeset a4e54f664175 (bug 1264948) for Static failures in Ion.cpp and undefined oomTest in bug1269756.js. r=backout

js/src/ds/LifoAlloc.h

@@ -162,9 +162,6 @@ class LifoAlloc
     size_t      defaultChunkSize_;
     size_t      curSize_;
     size_t      peakSize_;
-#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
-    bool        fallibleScope_;
-#endif
 
     void operator=(const LifoAlloc&) = delete;
     LifoAlloc(const LifoAlloc&) = delete;
@@ -234,9 +231,6 @@ class LifoAlloc
   public:
     explicit LifoAlloc(size_t defaultChunkSize)
       : peakSize_(0)
-#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
-      , fallibleScope_(true)
-#endif
     {
         reset(defaultChunkSize);
     }
@@ -276,17 +270,19 @@ class LifoAlloc
 
     MOZ_ALWAYS_INLINE
     void* alloc(size_t n) {
-#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
-        // Only simulate OOMs when we are not using the LifoAlloc as an
-        // infallible allocator.
-        if (fallibleScope_)
-            JS_OOM_POSSIBLY_FAIL();
-#endif
+        JS_OOM_POSSIBLY_FAIL();
         return allocImpl(n);
     }
 
     MOZ_ALWAYS_INLINE
-    void* allocInfallible(size_t n) {
+    void* allocInfallibleOrAssert(size_t n) {
+        void* result = allocImpl(n);
+        MOZ_RELEASE_ASSERT(result, "[OOM] Is it really infallible?");
+        return result;
+    }
+
+    MOZ_ALWAYS_INLINE
+    void* allocInfallibleOrCrash(size_t n) {
         AutoEnterOOMUnsafeRegion oomUnsafe;
         if (void* result = allocImpl(n))
             return result;
@@ -294,12 +290,16 @@ class LifoAlloc
         return nullptr;
     }
 
+    MOZ_ALWAYS_INLINE
+    void* allocInfallible(size_t n) {
+        return allocInfallibleOrCrash(n);
+    }
+
     // Ensures that enough space exists to satisfy N bytes worth of
     // allocation requests, not necessarily contiguous. Note that this does
     // not guarantee a successful single allocation of N bytes.
     MOZ_ALWAYS_INLINE
     MOZ_MUST_USE bool ensureUnusedApproximate(size_t n) {
-        AutoFallibleScope fallibleAllocator(this);
         size_t total = 0;
         for (BumpChunk* chunk = latest; chunk; chunk = chunk->next()) {
             total += chunk->unused();
@@ -314,36 +314,6 @@ class LifoAlloc
         return true;
     }
 
-    MOZ_ALWAYS_INLINE
-    void setAsInfallibleByDefault() {
-#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
-        fallibleScope_ = false;
-#endif
-    }
-
-    class MOZ_RAII AutoFallibleScope {
-#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
-        LifoAlloc* lifoAlloc_;
-        bool prevFallibleScope_;
-        MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
-
-      public:
-        explicit AutoFallibleScope(LifoAlloc* lifoAlloc MOZ_GUARD_OBJECT_NOTIFIER_PARAM) {
-            MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-            lifoAlloc_ = lifoAlloc;
-            prevFallibleScope_ = lifoAlloc->fallibleScope_;
-            lifoAlloc->fallibleScope_ = true;
-        }
-
-        ~AutoFallibleScope() {
-            lifoAlloc_->fallibleScope_ = prevFallibleScope_;
-        }
-#else
-      public:
-        explicit AutoFallibleScope(LifoAlloc*) {}
-#endif
-    };
-
     template <typename T>
     T* newArray(size_t count) {
         static_assert(mozilla::IsPod<T>::value,
@@ -529,7 +499,6 @@ class MOZ_NON_TEMPORARY_CLASS LifoAllocScope
 {
     LifoAlloc*      lifoAlloc;
     LifoAlloc::Mark mark;
-    LifoAlloc::AutoFallibleScope fallibleScope;
     bool            shouldRelease;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
@@ -538,7 +507,6 @@ class MOZ_NON_TEMPORARY_CLASS LifoAllocScope
                             MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
       : lifoAlloc(lifoAlloc),
         mark(lifoAlloc->mark()),
-        fallibleScope(lifoAlloc),
         shouldRelease(true)
     {
         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

js/src/jit-test/tests/ion/bug1264948.js

@@ -1,21 +0,0 @@
-if (!('oomTest' in this))
-    quit();
-
-loadFile(`
-  T = TypedObject
-  ObjectStruct = new T.StructType({f: T.Object})
-  var o = new ObjectStruct
-  function testGC(p) {
-    for (; i < 5; i++)
-        whatever.push;
-  }
-  testGC(o)
-  function writeObject()
-    o.f = v
-    writeObject({function() { } })
-  for (var i ; i < 5 ; ++i)
-    try {} catch (StringStruct) {}
-`);
-function loadFile(lfVarx) {
-  oomTest(Function(lfVarx));
-}

js/src/jit-test/tests/ion/bug1269756.js

@@ -1,5 +0,0 @@
-oomTest(function() {
-    m = parseModule(`while (x && NaN) prototype; let x`);
-    m.declarationInstantiation();
-    m.evaluation();
-})

js/src/jit/JitAllocPolicy.h

@@ -34,18 +34,15 @@ class TempAllocator
 
     explicit TempAllocator(LifoAlloc* lifoAlloc)
       : lifoScope_(lifoAlloc)
-    {
-        lifoAlloc->setAsInfallibleByDefault();
-    }
+    { }
 
     void* allocateInfallible(size_t bytes)
     {
-        return lifoScope_.alloc().allocInfallible(bytes);
+        return lifoScope_.alloc().allocInfallibleOrAssert(bytes);
     }
 
-    MOZ_MUST_USE void* allocate(size_t bytes)
+    void* allocate(size_t bytes)
     {
-        LifoAlloc::AutoFallibleScope fallibleAllocator(lifoAlloc());
         void* p = lifoScope_.alloc().alloc(bytes);
         if (!ensureBallast())
             return nullptr;
@@ -53,9 +50,8 @@ class TempAllocator
     }
 
     template <typename T>
-    MOZ_MUST_USE T* allocateArray(size_t n)
+    T* allocateArray(size_t n)
     {
-        LifoAlloc::AutoFallibleScope fallibleAllocator(lifoAlloc());
         size_t bytes;
         if (MOZ_UNLIKELY(!CalculateAllocSize<T>(n, &bytes)))
             return nullptr;
@@ -69,12 +65,12 @@ class TempAllocator
     struct Fallible { TempAllocator& alloc; };
     Fallible fallible() { return { *this }; }
 
-    LifoAlloc* lifoAlloc() {
+    LifoAlloc* lifoAlloc()
+    {
         return &lifoScope_.alloc();
     }
 
     MOZ_MUST_USE bool ensureBallast() {
-        JS_OOM_POSSIBLY_FAIL_BOOL();
         return lifoScope_.alloc().ensureUnusedApproximate(BallastSize);
     }
 };