Bug 1492977: Mark returns-false-for-retry functions as Pure r=tcampbell
authorIain Ireland <iireland@mozilla.com>
Wed, 10 Oct 2018 19:18:10 +0000
changeset 496333 81dd098adbd8984f9491eae22dac152cf4fb2d71
parent 496332 2c21c87e773ee1bfd796079fe5ffe06c2057b9ae
child 496334 da3163c05c7ee076a6f91c25d4fe5bf5bcb13429
push id9984
push userffxbld-merge
push dateMon, 15 Oct 2018 21:07:35 +0000
treeherdermozilla-beta@183d27ea8570 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerstcampbell
bugs1492977
milestone64.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 1492977: Mark returns-false-for-retry functions as Pure r=tcampbell Differential Revision: https://phabricator.services.mozilla.com/D7942
js/src/jit/BaselineCacheIRCompiler.cpp
js/src/jit/CacheIRCompiler.cpp
js/src/jit/CodeGenerator.cpp
js/src/jit/IonCacheIRCompiler.cpp
js/src/jit/VMFunctions.cpp
js/src/jit/VMFunctions.h
js/src/jsnum.cpp
js/src/jsnum.h
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArgumentsObject.h
js/src/vm/NativeObject.cpp
js/src/vm/NativeObject.h
--- a/js/src/jit/BaselineCacheIRCompiler.cpp
+++ b/js/src/jit/BaselineCacheIRCompiler.cpp
@@ -406,17 +406,17 @@ BaselineCacheIRCompiler::emitGuardSpecif
     // function to do the comparison.
     LiveRegisterSet volatileRegs(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(scratch);
     masm.loadPtr(atomAddr, scratch);
     masm.passABIArg(scratch);
     masm.passABIArg(str);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, EqualStringsHelper));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, EqualStringsHelperPure));
     masm.mov(ReturnReg, scratch);
 
     LiveRegisterSet ignore;
     ignore.add(scratch);
     masm.PopRegsInMaskIgnore(volatileRegs, ignore);
     masm.branchIfFalseBool(scratch, failure->label());
 
     masm.bind(&done);
@@ -492,17 +492,17 @@ BaselineCacheIRCompiler::emitGuardHasGet
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(scratch1);
     masm.loadJSContext(scratch1);
     masm.passABIArg(scratch1);
     masm.passABIArg(obj);
     masm.loadPtr(shapeAddr, scratch2);
     masm.passABIArg(scratch2);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, ObjectHasGetterSetter));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, ObjectHasGetterSetterPure));
     masm.mov(ReturnReg, scratch1);
     masm.PopRegsInMask(volatileRegs);
 
     masm.branchIfFalseBool(scratch1, failure->label());
     return true;
 }
 
 bool
@@ -1072,17 +1072,17 @@ BaselineCacheIRCompiler::emitAddAndStore
     bool changeGroup = reader.readBool();
     Address newGroupAddr = stubAddress(reader.stubOffset());
     Address newShapeAddr = stubAddress(reader.stubOffset());
 
     if (op == CacheOp::AllocateAndStoreDynamicSlot) {
         // We have to (re)allocate dynamic slots. Do this first, as it's the
         // only fallible operation here. This simplifies the callTypeUpdateIC
         // call below: it does not have to worry about saving registers used by
-        // failure paths. Note that growSlotsDontReportOOM is fallible but does
+        // failure paths. Note that growSlotsPure is fallible but does
         // not GC.
         Address numNewSlotsAddr = stubAddress(reader.stubOffset());
 
         FailurePath* failure;
         if (!addFailurePath(&failure)) {
             return false;
         }
 
@@ -1090,17 +1090,17 @@ BaselineCacheIRCompiler::emitAddAndStore
         masm.PushRegsInMask(save);
 
         masm.setupUnalignedABICall(scratch1);
         masm.loadJSContext(scratch1);
         masm.passABIArg(scratch1);
         masm.passABIArg(obj);
         masm.load32(numNewSlotsAddr, scratch2);
         masm.passABIArg(scratch2);
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::growSlotsDontReportOOM));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::growSlotsPure));
         masm.mov(ReturnReg, scratch1);
 
         LiveRegisterSet ignore;
         ignore.add(scratch1);
         masm.PopRegsInMaskIgnore(save, ignore);
 
         masm.branchIfFalseBool(scratch1, failure->label());
     }
@@ -1421,17 +1421,17 @@ BaselineCacheIRCompiler::emitStoreDenseE
         LiveRegisterSet save(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
         save.takeUnchecked(scratch);
         masm.PushRegsInMask(save);
 
         masm.setupUnalignedABICall(scratch);
         masm.loadJSContext(scratch);
         masm.passABIArg(scratch);
         masm.passABIArg(obj);
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::addDenseElementDontReportOOM));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::addDenseElementPure));
         masm.mov(ReturnReg, scratch);
 
         masm.PopRegsInMask(save);
         masm.branchIfFalseBool(scratch, failure->label());
 
         // Load the reallocated elements pointer.
         masm.loadPtr(Address(obj, NativeObject::offsetOfElements()), scratch);
 
@@ -1561,17 +1561,17 @@ BaselineCacheIRCompiler::emitArrayPush()
     LiveRegisterSet save(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
     save.takeUnchecked(scratch);
     masm.PushRegsInMask(save);
 
     masm.setupUnalignedABICall(scratch);
     masm.loadJSContext(scratch);
     masm.passABIArg(scratch);
     masm.passABIArg(obj);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::addDenseElementDontReportOOM));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::addDenseElementPure));
     masm.mov(ReturnReg, scratch);
 
     masm.PopRegsInMask(save);
     masm.branchIfFalseBool(scratch, failure->label());
 
     // Load the reallocated elements pointer.
     masm.loadPtr(Address(obj, NativeObject::offsetOfElements()), scratch);
 
--- a/js/src/jit/CacheIRCompiler.cpp
+++ b/js/src/jit/CacheIRCompiler.cpp
@@ -1960,36 +1960,36 @@ CacheIRCompiler::emitGuardAndGetNumberFr
         LiveRegisterSet volatileRegs(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
         masm.PushRegsInMask(volatileRegs);
 
         masm.setupUnalignedABICall(scratch);
         masm.loadJSContext(scratch);
         masm.passABIArg(scratch);
         masm.passABIArg(str);
         masm.passABIArg(output.payloadOrValueReg());
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, StringToNumberDontReportOOM));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, StringToNumberPure));
         masm.mov(ReturnReg, scratch);
 
         LiveRegisterSet ignore;
         ignore.add(scratch);
         masm.PopRegsInMaskIgnore(volatileRegs, ignore);
 
         Label ok;
         masm.branchIfTrueBool(scratch, &ok);
         {
-            // OOM path, recovered by StringToNumberDontReportOOM.
+            // OOM path, recovered by StringToNumberPure.
             //
             // Use addToStackPtr instead of freeStack as freeStack tracks stack height
             // flow-insensitively, and using it twice would confuse the stack height
-            // tracking. 
+            // tracking.
             masm.addToStackPtr(Imm32(sizeof(double)));
             masm.jump(failure->label());
         }
         masm.bind(&ok);
-        
+
         masm.loadDouble(Address(output.payloadOrValueReg(), 0), FloatReg0);
         masm.boxDouble(FloatReg0, output, FloatReg0);
         masm.freeStack(sizeof(double));
     }
     masm.bind(&done);
     return true;
 }
 
@@ -3798,17 +3798,17 @@ CacheIRCompiler::emitCallObjectHasSparse
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(scratch1);
     masm.loadJSContext(scratch1);
     masm.passABIArg(scratch1);
     masm.passABIArg(obj);
     masm.passABIArg(index);
     masm.passABIArg(scratch2);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, HasNativeElement));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, HasNativeElementPure));
     masm.mov(ReturnReg, scratch1);
     masm.PopRegsInMask(volatileRegs);
 
     Label ok;
     uint32_t framePushed = masm.framePushed();
     masm.branchIfTrueBool(scratch1, &ok);
     masm.adjustStack(sizeof(Value));
     masm.jump(failure->label());
@@ -3945,19 +3945,19 @@ CacheIRCompiler::emitMegamorphicLoadSlot
     masm.setupUnalignedABICall(scratch1);
     masm.loadJSContext(scratch1);
     masm.passABIArg(scratch1);
     masm.passABIArg(obj);
     emitLoadStubField(name, scratch2);
     masm.passABIArg(scratch2);
     masm.passABIArg(scratch3);
     if (handleMissing) {
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (GetNativeDataProperty<true>)));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (GetNativeDataPropertyPure<true>)));
     } else {
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (GetNativeDataProperty<false>)));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (GetNativeDataPropertyPure<false>)));
     }
     masm.mov(ReturnReg, scratch2);
     masm.PopRegsInMask(volatileRegs);
 
     masm.loadTypedOrValue(Address(masm.getStackPointer(), 0), output);
     masm.adjustStack(sizeof(Value));
 
     masm.branchIfFalseBool(scratch2, failure->label());
@@ -3996,19 +3996,19 @@ CacheIRCompiler::emitMegamorphicStoreSlo
     masm.setupUnalignedABICall(scratch1);
     masm.loadJSContext(scratch1);
     masm.passABIArg(scratch1);
     masm.passABIArg(obj);
     emitLoadStubField(name, scratch2);
     masm.passABIArg(scratch2);
     masm.passABIArg(val.scratchReg());
     if (needsTypeBarrier) {
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (SetNativeDataProperty<true>)));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (SetNativeDataPropertyPure<true>)));
     } else {
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (SetNativeDataProperty<false>)));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (SetNativeDataPropertyPure<false>)));
     }
     masm.mov(ReturnReg, scratch1);
     masm.PopRegsInMask(volatileRegs);
 
     masm.loadValue(Address(masm.getStackPointer(), 0), val);
     masm.adjustStack(sizeof(Value));
 
     masm.branchIfFalseBool(scratch1, failure->label());
@@ -4054,17 +4054,17 @@ CacheIRCompiler::emitCallInt32ToString()
     LiveRegisterSet volatileRegs(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
     volatileRegs.takeUnchecked(result);
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(result);
     masm.loadJSContext(result);
     masm.passABIArg(result);
     masm.passABIArg(input);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (js::Int32ToStringHelper)));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (js::Int32ToStringHelperPure)));
 
     masm.mov(ReturnReg, result);
     masm.PopRegsInMask(volatileRegs);
 
     masm.branchPtr(Assembler::Equal, result, ImmPtr(0), failure->label());
     return true;
 }
 
@@ -4085,17 +4085,17 @@ CacheIRCompiler::emitCallNumberToString(
     volatileRegs.takeUnchecked(result);
     volatileRegs.addUnchecked(FloatReg0);
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(result);
     masm.loadJSContext(result);
     masm.passABIArg(result);
     masm.passABIArg(FloatReg0, MoveOp::DOUBLE);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (js::NumberToStringHelper)));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, (js::NumberToStringHelperPure)));
 
     masm.mov(ReturnReg, result);
     masm.PopRegsInMask(volatileRegs);
 
     masm.branchPtr(Assembler::Equal, result, ImmPtr(0), failure->label());
     return true;
 }
 
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -6912,33 +6912,33 @@ CodeGenerator::visitCreateArgumentsObjec
     if (ArgumentsObject* templateObj = lir->mir()->templateObject()) {
         Register objTemp = ToRegister(lir->temp1());
         Register cxTemp = ToRegister(lir->temp2());
 
         masm.Push(callObj);
 
         // Try to allocate an arguments object. This will leave the reserved
         // slots uninitialized, so it's important we don't GC until we
-        // initialize these slots in ArgumentsObject::finishForIon.
+        // initialize these slots in ArgumentsObject::finishForIonPure.
         Label failure;
         TemplateObject templateObject(templateObj);
         masm.createGCObject(objTemp, temp, templateObject, gc::DefaultHeap, &failure,
                             /* initContents = */ false);
 
         masm.moveStackPtrTo(temp);
         masm.addPtr(Imm32(masm.framePushed()), temp);
 
         masm.setupUnalignedABICall(cxTemp);
         masm.loadJSContext(cxTemp);
         masm.passABIArg(cxTemp);
         masm.passABIArg(temp);
         masm.passABIArg(callObj);
         masm.passABIArg(objTemp);
 
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, ArgumentsObject::finishForIon));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, ArgumentsObject::finishForIonPure));
         masm.branchTestPtr(Assembler::Zero, ReturnReg, ReturnReg, &failure);
 
         // Discard saved callObj on the stack.
         masm.addToStackPtr(Imm32(sizeof(uintptr_t)));
         masm.jump(&done);
 
         masm.bind(&failure);
         masm.Pop(callObj);
--- a/js/src/jit/IonCacheIRCompiler.cpp
+++ b/js/src/jit/IonCacheIRCompiler.cpp
@@ -829,17 +829,17 @@ IonCacheIRCompiler::emitGuardSpecificAto
     // function to do the comparison.
     LiveRegisterSet volatileRegs(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(scratch);
     masm.movePtr(ImmGCPtr(atom), scratch);
     masm.passABIArg(scratch);
     masm.passABIArg(str);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, EqualStringsHelper));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, EqualStringsHelperPure));
     masm.mov(ReturnReg, scratch);
 
     LiveRegisterSet ignore;
     ignore.add(scratch);
     masm.PopRegsInMaskIgnore(volatileRegs, ignore);
     masm.branchIfFalseBool(scratch, failure->label());
 
     masm.bind(&done);
@@ -911,17 +911,17 @@ IonCacheIRCompiler::emitGuardHasGetterSe
     masm.PushRegsInMask(volatileRegs);
 
     masm.setupUnalignedABICall(scratch1);
     masm.loadJSContext(scratch1);
     masm.passABIArg(scratch1);
     masm.passABIArg(obj);
     masm.movePtr(ImmGCPtr(shape), scratch2);
     masm.passABIArg(scratch2);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, ObjectHasGetterSetter));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, ObjectHasGetterSetterPure));
     masm.mov(ReturnReg, scratch1);
     masm.PopRegsInMask(volatileRegs);
 
     masm.branchIfFalseBool(scratch1, failure->label());
     return true;
 }
 
 bool
@@ -1601,31 +1601,31 @@ IonCacheIRCompiler::emitAddAndStoreSlotS
     if (!addFailurePath(&failure)) {
         return false;
     }
 
     EmitCheckPropertyTypes(masm, typeCheckInfo_, obj, val, *liveRegs_, failure->label());
 
     if (op == CacheOp::AllocateAndStoreDynamicSlot) {
         // We have to (re)allocate dynamic slots. Do this first, as it's the
-        // only fallible operation here. Note that growSlotsDontReportOOM is
+        // only fallible operation here. Note that growSlotsPure is
         // fallible but does not GC.
         int32_t numNewSlots = int32StubField(reader.stubOffset());
         MOZ_ASSERT(numNewSlots > 0);
 
         LiveRegisterSet save(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
         masm.PushRegsInMask(save);
 
         masm.setupUnalignedABICall(scratch1);
         masm.loadJSContext(scratch1);
         masm.passABIArg(scratch1);
         masm.passABIArg(obj);
         masm.move32(Imm32(numNewSlots), scratch2.ref());
         masm.passABIArg(scratch2.ref());
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::growSlotsDontReportOOM));
+        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::growSlotsPure));
         masm.mov(ReturnReg, scratch1);
 
         LiveRegisterSet ignore;
         ignore.add(scratch1);
         masm.PopRegsInMaskIgnore(save, ignore);
 
         masm.branchIfFalseBool(scratch1, failure->label());
     }
@@ -1950,17 +1950,17 @@ IonCacheIRCompiler::emitStoreDenseElemen
     LiveRegisterSet save(GeneralRegisterSet::Volatile(), liveVolatileFloatRegs());
     save.takeUnchecked(scratch1);
     masm.PushRegsInMask(save);
 
     masm.setupUnalignedABICall(scratch1);
     masm.loadJSContext(scratch1);
     masm.passABIArg(scratch1);
     masm.passABIArg(obj);
-    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::addDenseElementDontReportOOM));
+    masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NativeObject::addDenseElementPure));
     masm.mov(ReturnReg, scratch1);
 
     masm.PopRegsInMask(save);
     masm.branchIfFalseBool(scratch1, failure->label());
 
     // Load the reallocated elements pointer.
     masm.loadPtr(Address(obj, NativeObject::offsetOfElements()), scratch1);
 
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -1596,17 +1596,17 @@ CallNativeSetter(JSContext* cx, HandleFu
     vp[0].setObject(*callee.get());
     vp[1].setObject(*obj.get());
     vp[2].set(rhs);
 
     return natfun(cx, 1, vp.begin());
 }
 
 bool
-EqualStringsHelper(JSString* str1, JSString* str2)
+EqualStringsHelperPure(JSString* str1, JSString* str2)
 {
     // IC code calls this directly so we shouldn't GC.
     AutoUnsafeCallWithABI unsafe;
 
     MOZ_ASSERT(str1->isAtom());
     MOZ_ASSERT(!str2->isAtom());
     MOZ_ASSERT(str1->length() == str2->length());
 
@@ -1627,17 +1627,17 @@ CheckIsCallable(JSContext* cx, HandleVal
         return ThrowCheckIsCallable(cx, kind);
     }
 
     return true;
 }
 
 template <bool HandleMissing>
 static MOZ_ALWAYS_INLINE bool
-GetNativeDataProperty(JSContext* cx, NativeObject* obj, jsid id, Value* vp)
+GetNativeDataPropertyPure(JSContext* cx, NativeObject* obj, jsid id, Value* vp)
 {
     // Fast path used by megamorphic IC stubs. Unlike our other property
     // lookup paths, this is optimized to be as fast as possible for simple
     // data property lookups.
 
     AutoUnsafeCallWithABI unsafe;
 
     MOZ_ASSERT(JSID_IS_ATOM(id) || JSID_IS_SYMBOL(id));
@@ -1672,28 +1672,28 @@ GetNativeDataProperty(JSContext* cx, Nat
             return false;
         }
         obj = &proto->as<NativeObject>();
     }
 }
 
 template <bool HandleMissing>
 bool
-GetNativeDataProperty(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp)
+GetNativeDataPropertyPure(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp)
 {
     // Condition checked by caller.
     MOZ_ASSERT(obj->isNative());
-    return GetNativeDataProperty<HandleMissing>(cx, &obj->as<NativeObject>(), NameToId(name), vp);
+    return GetNativeDataPropertyPure<HandleMissing>(cx, &obj->as<NativeObject>(), NameToId(name), vp);
 }
 
 template bool
-GetNativeDataProperty<true>(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp);
+GetNativeDataPropertyPure<true>(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp);
 
 template bool
-GetNativeDataProperty<false>(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp);
+GetNativeDataPropertyPure<false>(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp);
 
 static MOZ_ALWAYS_INLINE bool
 ValueToAtomOrSymbolPure(JSContext* cx, Value& idVal, jsid* id)
 {
     if (MOZ_LIKELY(idVal.isString())) {
         JSString* s = idVal.toString();
         JSAtom* atom;
         if (s->isAtom()) {
@@ -1736,28 +1736,28 @@ GetNativeDataPropertyByValuePure(JSConte
     // vp[0] contains the id, result will be stored in vp[1].
     Value idVal = vp[0];
     jsid id;
     if (!ValueToAtomOrSymbolPure(cx, idVal, &id)) {
         return false;
     }
 
     Value* res = vp + 1;
-    return GetNativeDataProperty<HandleMissing>(cx, &obj->as<NativeObject>(), id, res);
+    return GetNativeDataPropertyPure<HandleMissing>(cx, &obj->as<NativeObject>(), id, res);
 }
 
 template bool
 GetNativeDataPropertyByValuePure<true>(JSContext* cx, JSObject* obj, Value* vp);
 
 template bool
 GetNativeDataPropertyByValuePure<false>(JSContext* cx, JSObject* obj, Value* vp);
 
 template <bool NeedsTypeBarrier>
 bool
-SetNativeDataProperty(JSContext* cx, JSObject* obj, PropertyName* name, Value* val)
+SetNativeDataPropertyPure(JSContext* cx, JSObject* obj, PropertyName* name, Value* val)
 {
     AutoUnsafeCallWithABI unsafe;
 
     if (MOZ_UNLIKELY(!obj->isNative())) {
         return false;
     }
 
     NativeObject* nobj = &obj->as<NativeObject>();
@@ -1773,23 +1773,23 @@ SetNativeDataProperty(JSContext* cx, JSO
         return false;
     }
 
     nobj->setSlot(shape->slot(), *val);
     return true;
 }
 
 template bool
-SetNativeDataProperty<true>(JSContext* cx, JSObject* obj, PropertyName* name, Value* val);
+SetNativeDataPropertyPure<true>(JSContext* cx, JSObject* obj, PropertyName* name, Value* val);
 
 template bool
-SetNativeDataProperty<false>(JSContext* cx, JSObject* obj, PropertyName* name, Value* val);
+SetNativeDataPropertyPure<false>(JSContext* cx, JSObject* obj, PropertyName* name, Value* val);
 
 bool
-ObjectHasGetterSetter(JSContext* cx, JSObject* objArg, Shape* propShape)
+ObjectHasGetterSetterPure(JSContext* cx, JSObject* objArg, Shape* propShape)
 {
     AutoUnsafeCallWithABI unsafe;
 
     MOZ_ASSERT(propShape->hasGetterObject() || propShape->hasSetterObject());
 
     // Window objects may require outerizing (passing the WindowProxy to the
     // getter/setter), so we don't support them here.
     if (MOZ_UNLIKELY(!objArg->isNative() || IsWindow(objArg))) {
@@ -1888,17 +1888,17 @@ HasNativeDataPropertyPure(JSContext* cx,
 template bool
 HasNativeDataPropertyPure<true>(JSContext* cx, JSObject* obj, Value* vp);
 
 template bool
 HasNativeDataPropertyPure<false>(JSContext* cx, JSObject* obj, Value* vp);
 
 
 bool
-HasNativeElement(JSContext* cx, NativeObject* obj, int32_t index, Value* vp)
+HasNativeElementPure(JSContext* cx, NativeObject* obj, int32_t index, Value* vp)
 {
     AutoUnsafeCallWithABI unsafe;
 
     MOZ_ASSERT(obj->getClass()->isNative());
     MOZ_ASSERT(!obj->getOpsHasProperty());
     MOZ_ASSERT(!obj->getOpsLookupProperty());
     MOZ_ASSERT(!obj->getOpsGetOwnPropertyDescriptor());
 
--- a/js/src/jit/VMFunctions.h
+++ b/js/src/jit/VMFunctions.h
@@ -912,42 +912,42 @@ MOZ_MUST_USE bool
 CallNativeGetter(JSContext* cx, HandleFunction callee, HandleObject obj,
                  MutableHandleValue result);
 
 MOZ_MUST_USE bool
 CallNativeSetter(JSContext* cx, HandleFunction callee, HandleObject obj,
                  HandleValue rhs);
 
 MOZ_MUST_USE bool
-EqualStringsHelper(JSString* str1, JSString* str2);
+EqualStringsHelperPure(JSString* str1, JSString* str2);
 
 MOZ_MUST_USE bool
 CheckIsCallable(JSContext* cx, HandleValue v, CheckIsCallableKind kind);
 
 template <bool HandleMissing>
 bool
-GetNativeDataProperty(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp);
+GetNativeDataPropertyPure(JSContext* cx, JSObject* obj, PropertyName* name, Value* vp);
 
 template <bool HandleMissing>
 bool
 GetNativeDataPropertyByValuePure(JSContext* cx, JSObject* obj, Value* vp);
 
 template <bool HasOwn>
 bool
 HasNativeDataPropertyPure(JSContext* cx, JSObject* obj, Value* vp);
 
 bool
-HasNativeElement(JSContext* cx, NativeObject* obj, int32_t index, Value* vp);
+HasNativeElementPure(JSContext* cx, NativeObject* obj, int32_t index, Value* vp);
 
 template <bool NeedsTypeBarrier>
 bool
-SetNativeDataProperty(JSContext* cx, JSObject* obj, PropertyName* name, Value* val);
+SetNativeDataPropertyPure(JSContext* cx, JSObject* obj, PropertyName* name, Value* val);
 
 bool
-ObjectHasGetterSetter(JSContext* cx, JSObject* obj, Shape* propShape);
+ObjectHasGetterSetterPure(JSContext* cx, JSObject* obj, Shape* propShape);
 
 JSString*
 TypeOfObject(JSObject* obj, JSRuntime* rt);
 
 bool
 GetPrototypeOf(JSContext* cx, HandleObject target, MutableHandleValue rval);
 
 void
--- a/js/src/jsnum.cpp
+++ b/js/src/jsnum.cpp
@@ -715,17 +715,17 @@ js::Int32ToString(JSContext* cx, int32_t
 
 template JSFlatString*
 js::Int32ToString<CanGC>(JSContext* cx, int32_t si);
 
 template JSFlatString*
 js::Int32ToString<NoGC>(JSContext* cx, int32_t si);
 
 JSFlatString*
-js::Int32ToStringHelper(JSContext* cx, int32_t si)
+js::Int32ToStringHelperPure(JSContext* cx, int32_t si)
 {
     AutoUnsafeCallWithABI unsafe;
     JSFlatString* res = Int32ToString<NoGC>(cx, si);
     if (!res) {
         cx->recoverFromOutOfMemory();
     }
     return res;
 }
@@ -1525,17 +1525,17 @@ js::NumberToString(JSContext* cx, double
 
 template JSString*
 js::NumberToString<CanGC>(JSContext* cx, double d);
 
 template JSString*
 js::NumberToString<NoGC>(JSContext* cx, double d);
 
 JSString*
-js::NumberToStringHelper(JSContext* cx, double d)
+js::NumberToStringHelperPure(JSContext* cx, double d)
 {
     AutoUnsafeCallWithABI unsafe;
     JSString* res = NumberToString<NoGC>(cx, d);
     if (!res) {
         cx->recoverFromOutOfMemory();
     }
     return res;
 }
@@ -1709,17 +1709,17 @@ js::StringToNumber(JSContext* cx, JSStri
     }
 
     return linearStr->hasLatin1Chars()
            ? CharsToNumber(cx, linearStr->latin1Chars(nogc), str->length(), result)
            : CharsToNumber(cx, linearStr->twoByteChars(nogc), str->length(), result);
 }
 
 bool
-js::StringToNumberDontReportOOM(JSContext* cx, JSString* str, double* result)
+js::StringToNumberPure(JSContext* cx, JSString* str, double* result)
 {
     // IC Code calls this directly.
     AutoUnsafeCallWithABI unsafe;
 
     if (!StringToNumber(cx, str, result)) {
         cx->recoverFromOutOfMemory();
         return false;
     }
--- a/js/src/jsnum.h
+++ b/js/src/jsnum.h
@@ -56,27 +56,27 @@ InitNumberClass(JSContext* cx, Handle<Gl
  * ECMA-262-5 section 9.8.1; but note that it handles integers specially for
  * performance.  See also js::NumberToCString().
  */
 template <AllowGC allowGC>
 extern JSString*
 NumberToString(JSContext* cx, double d);
 
 extern JSString*
-NumberToStringHelper(JSContext* cx, double d);
+NumberToStringHelperPure(JSContext* cx, double d);
 
 extern JSAtom*
 NumberToAtom(JSContext* cx, double d);
 
 template <AllowGC allowGC>
 extern JSFlatString*
 Int32ToString(JSContext* cx, int32_t i);
 
 extern JSFlatString*
-Int32ToStringHelper(JSContext* cx, int32_t i);
+Int32ToStringHelperPure(JSContext* cx, int32_t i);
 
 extern JSAtom*
 Int32ToAtom(JSContext* cx, int32_t si);
 
 // ES6 15.7.3.12
 extern bool
 IsInteger(const Value& val);
 
@@ -194,17 +194,17 @@ GetFullInteger(JSContext* cx, const Char
 template <typename CharT>
 extern MOZ_MUST_USE bool
 GetDecimalInteger(JSContext* cx, const CharT* start, const CharT* end, double* dp);
 
 extern MOZ_MUST_USE bool
 StringToNumber(JSContext* cx, JSString* str, double* result);
 
 extern MOZ_MUST_USE bool
-StringToNumberDontReportOOM(JSContext* cx, JSString* str, double* result);
+StringToNumberPure(JSContext* cx, JSString* str, double* result);
 
 /* ES5 9.3 ToNumber, overwriting *vp with the appropriate number value. */
 MOZ_ALWAYS_INLINE MOZ_MUST_USE bool
 ToNumber(JSContext* cx, JS::MutableHandleValue vp)
 {
     if (vp.isNumber()) {
         return true;
     }
--- a/js/src/vm/ArgumentsObject.cpp
+++ b/js/src/vm/ArgumentsObject.cpp
@@ -380,18 +380,18 @@ ArgumentsObject::createForIon(JSContext*
     MOZ_ASSERT(jit::CalleeTokenIsFunction(token));
     RootedFunction callee(cx, jit::CalleeTokenToFunction(token));
     RootedObject callObj(cx, scopeChain->is<CallObject>() ? scopeChain.get() : nullptr);
     CopyJitFrameArgs copy(frame, callObj);
     return create(cx, callee, frame->numActualArgs(), copy);
 }
 
 /* static */ ArgumentsObject*
-ArgumentsObject::finishForIon(JSContext* cx, jit::JitFrameLayout* frame,
-                              JSObject* scopeChain, ArgumentsObject* obj)
+ArgumentsObject::finishForIonPure(JSContext* cx, jit::JitFrameLayout* frame,
+                                  JSObject* scopeChain, ArgumentsObject* obj)
 {
     // JIT code calls this directly (no callVM), because it's faster, so we're
     // not allowed to GC in here.
     AutoUnsafeCallWithABI unsafe;
 
     JSFunction* callee = jit::CalleeTokenToFunction(frame->calleeToken());
     RootedObject callObj(cx, scopeChain->is<CallObject>() ? scopeChain : nullptr);
     CopyJitFrameArgs copy(frame, callObj);
--- a/js/src/vm/ArgumentsObject.h
+++ b/js/src/vm/ArgumentsObject.h
@@ -205,17 +205,17 @@ class ArgumentsObject : public NativeObj
     static ArgumentsObject* createUnexpected(JSContext* cx, AbstractFramePtr frame);
     static ArgumentsObject* createForIon(JSContext* cx, jit::JitFrameLayout* frame,
                                          HandleObject scopeChain);
 
     /*
      * Allocate ArgumentsData and fill reserved slots after allocating an
      * ArgumentsObject in Ion code.
      */
-    static ArgumentsObject* finishForIon(JSContext* cx, jit::JitFrameLayout* frame,
+    static ArgumentsObject* finishForIonPure(JSContext* cx, jit::JitFrameLayout* frame,
                                          JSObject* scopeChain, ArgumentsObject* obj);
 
     static ArgumentsObject* createTemplateObject(JSContext* cx, bool mapped);
 
     /*
      * Return the initial length of the arguments.  This may differ from the
      * current value of arguments.length!
      */
--- a/js/src/vm/NativeObject.cpp
+++ b/js/src/vm/NativeObject.cpp
@@ -460,30 +460,30 @@ NativeObject::growSlots(JSContext* cx, u
     slots_ = newslots;
 
     Debug_SetSlotRangeToCrashOnTouch(slots_ + oldCount, newCount - oldCount);
 
     return true;
 }
 
 /* static */ bool
-NativeObject::growSlotsDontReportOOM(JSContext* cx, NativeObject* obj, uint32_t newCount)
+NativeObject::growSlotsPure(JSContext* cx, NativeObject* obj, uint32_t newCount)
 {
     // IC code calls this directly.
     AutoUnsafeCallWithABI unsafe;
 
     if (!obj->growSlots(cx, obj->numDynamicSlots(), newCount)) {
         cx->recoverFromOutOfMemory();
         return false;
     }
     return true;
 }
 
 /* static */ bool
-NativeObject::addDenseElementDontReportOOM(JSContext* cx, NativeObject* obj)
+NativeObject::addDenseElementPure(JSContext* cx, NativeObject* obj)
 {
     // IC code calls this directly.
     AutoUnsafeCallWithABI unsafe;
 
     MOZ_ASSERT(obj->getDenseInitializedLength() == obj->getDenseCapacity());
     MOZ_ASSERT(!obj->denseElementsAreCopyOnWrite());
     MOZ_ASSERT(obj->isExtensible());
     MOZ_ASSERT(!obj->isIndexed());
--- a/js/src/vm/NativeObject.h
+++ b/js/src/vm/NativeObject.h
@@ -829,24 +829,24 @@ class NativeObject : public ShapedObject
      */
     bool growSlots(JSContext* cx, uint32_t oldCount, uint32_t newCount);
     void shrinkSlots(JSContext* cx, uint32_t oldCount, uint32_t newCount);
 
     /*
      * This method is static because it's called from JIT code. On OOM, returns
      * false without leaving a pending exception on the context.
      */
-    static bool growSlotsDontReportOOM(JSContext* cx, NativeObject* obj, uint32_t newCount);
+    static bool growSlotsPure(JSContext* cx, NativeObject* obj, uint32_t newCount);
 
     /*
-     * Like growSlotsDontReportOOM but for dense elements. This will return
+     * Like growSlotsPure but for dense elements. This will return
      * false if we failed to allocate a dense element for some reason (OOM, too
      * many dense elements, non-writable array length, etc).
      */
-    static bool addDenseElementDontReportOOM(JSContext* cx, NativeObject* obj);
+    static bool addDenseElementPure(JSContext* cx, NativeObject* obj);
 
     bool hasDynamicSlots() const { return !!slots_; }
 
     /* Compute dynamicSlotsCount() for this object. */
     MOZ_ALWAYS_INLINE uint32_t numDynamicSlots() const;
 
     bool empty() const {
         return lastProperty()->isEmptyShape();