Bug 1531841: Make callVM/tailCallVM infallible in CacheIR compilers r=mgaudet
authorIain Ireland <iireland@mozilla.com>
Fri, 01 Mar 2019 20:48:28 +0000
changeset 462015 b38cbb00d7dd7bfb9fecd81f08275dc0265ac7ca
parent 462014 d8cdae952942c13e39008a5b6ab6400aa7cdfde1
child 462016 d4a7d1ef0bb971fee314e1b9738ab7cf01f21935
push id79418
push useriireland@mozilla.com
push dateFri, 01 Mar 2019 20:49:11 +0000
treeherderautoland@b38cbb00d7dd [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmgaudet
bugs1531841
milestone67.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 1531841: Make callVM/tailCallVM infallible in CacheIR compilers r=mgaudet Differential Revision: https://phabricator.services.mozilla.com/D21779
js/src/jit/BaselineCacheIRCompiler.cpp
js/src/jit/IonCacheIRCompiler.cpp
--- a/js/src/jit/BaselineCacheIRCompiler.cpp
+++ b/js/src/jit/BaselineCacheIRCompiler.cpp
@@ -33,18 +33,18 @@ Address CacheRegisterAllocator::addressO
 }
 
 // BaselineCacheIRCompiler compiles CacheIR to BaselineIC native code.
 class MOZ_RAII BaselineCacheIRCompiler : public CacheIRCompiler {
   bool inStubFrame_;
   bool makesGCCalls_;
   BaselineCacheIRStubKind kind_;
 
-  MOZ_MUST_USE bool callVM(MacroAssembler& masm, const VMFunction& fun);
-  MOZ_MUST_USE bool tailCallVM(MacroAssembler& masm, const VMFunction& fun);
+  void callVM(MacroAssembler& masm, const VMFunction& fun);
+  void tailCallVM(MacroAssembler& masm, const VMFunction& fun);
 
   MOZ_MUST_USE bool callTypeUpdateIC(Register obj, ValueOperand val,
                                      Register scratch,
                                      LiveGeneralRegisterSet saveRegs);
 
   MOZ_MUST_USE bool emitStoreSlotShared(bool isFixed);
   MOZ_MUST_USE bool emitAddAndStoreSlotShared(CacheOp op);
 
@@ -136,37 +136,35 @@ class MOZ_RAII AutoStubFrame {
     EmitBaselineLeaveStubFrame(masm, calledIntoIon);
   }
 
 #ifdef DEBUG
   ~AutoStubFrame() { MOZ_ASSERT(!compiler.inStubFrame_); }
 #endif
 };
 
-bool BaselineCacheIRCompiler::callVM(MacroAssembler& masm,
+void BaselineCacheIRCompiler::callVM(MacroAssembler& masm,
                                      const VMFunction& fun) {
   MOZ_ASSERT(inStubFrame_);
 
   TrampolinePtr code = cx_->runtime()->jitRuntime()->getVMWrapper(fun);
   MOZ_ASSERT(fun.expectTailCall == NonTailCall);
 
   EmitBaselineCallVM(code, masm);
-  return true;
 }
 
-bool BaselineCacheIRCompiler::tailCallVM(MacroAssembler& masm,
+void BaselineCacheIRCompiler::tailCallVM(MacroAssembler& masm,
                                          const VMFunction& fun) {
   MOZ_ASSERT(!inStubFrame_);
 
   TrampolinePtr code = cx_->runtime()->jitRuntime()->getVMWrapper(fun);
   MOZ_ASSERT(fun.expectTailCall == TailCall);
   size_t argSize = fun.explicitStackSlots() * sizeof(void*);
 
   EmitBaselineTailCallVM(code, masm, argSize);
-  return true;
 }
 
 static size_t GetEnteredOffset(BaselineCacheIRStubKind kind) {
   switch (kind) {
     case BaselineCacheIRStubKind::Regular:
       return ICCacheIR_Regular::offsetOfEnteredCount();
     case BaselineCacheIRStubKind::Updated:
       return ICCacheIR_Updated::offsetOfEnteredCount();
@@ -599,19 +597,17 @@ bool BaselineCacheIRCompiler::emitCallNa
   stubFrame.enter(masm, scratch);
 
   // Load the callee in the scratch register.
   masm.loadPtr(getterAddr, scratch);
 
   masm.Push(obj);
   masm.Push(scratch);
 
-  if (!callVM(masm, CallNativeGetterInfo)) {
-    return false;
-  }
+  callVM(masm, CallNativeGetterInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallProxyGetResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
@@ -625,19 +621,17 @@ bool BaselineCacheIRCompiler::emitCallPr
   stubFrame.enter(masm, scratch);
 
   // Load the jsid in the scratch register.
   masm.loadPtr(idAddr, scratch);
 
   masm.Push(scratch);
   masm.Push(obj);
 
-  if (!callVM(masm, ProxyGetPropertyInfo)) {
-    return false;
-  }
+  callVM(masm, ProxyGetPropertyInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallProxyGetByValueResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
@@ -648,19 +642,17 @@ bool BaselineCacheIRCompiler::emitCallPr
   allocator.discardStack(masm);
 
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.Push(idVal);
   masm.Push(obj);
 
-  if (!callVM(masm, ProxyGetPropertyByValueInfo)) {
-    return false;
-  }
+  callVM(masm, ProxyGetPropertyByValueInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallProxyHasPropResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
@@ -673,23 +665,19 @@ bool BaselineCacheIRCompiler::emitCallPr
 
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.Push(idVal);
   masm.Push(obj);
 
   if (hasOwn) {
-    if (!callVM(masm, ProxyHasOwnInfo)) {
-      return false;
-    }
+    callVM(masm, ProxyHasOwnInfo);
   } else {
-    if (!callVM(masm, ProxyHasInfo)) {
-      return false;
-    }
+    callVM(masm, ProxyHasInfo);
   }
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallNativeGetElementResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
@@ -702,19 +690,17 @@ bool BaselineCacheIRCompiler::emitCallNa
 
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.Push(index);
   masm.Push(TypedOrValueRegister(MIRType::Object, AnyRegister(obj)));
   masm.Push(obj);
 
-  if (!callVM(masm, NativeGetElementInfo)) {
-    return false;
-  }
+  callVM(masm, NativeGetElementInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitLoadUnboxedPropertyResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoOutputRegister output(*this);
@@ -884,19 +870,17 @@ bool BaselineCacheIRCompiler::emitCallSt
   // Load the group in the scratch register.
   masm.loadPtr(groupAddr, scratch);
 
   masm.Push(Imm32(INT32_MAX));
   masm.Push(scratch);
   masm.Push(sep);
   masm.Push(str);
 
-  if (!callVM(masm, StringSplitHelperInfo)) {
-    return false;
-  }
+  callVM(masm, StringSplitHelperInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCompareStringResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoOutputRegister output(*this);
@@ -920,21 +904,18 @@ bool BaselineCacheIRCompiler::emitCompar
   masm.bind(&slow);
   {
     AutoStubFrame stubFrame(*this);
     stubFrame.enter(masm, scratch);
 
     masm.Push(right);
     masm.Push(left);
 
-    if (!callVM(masm, (op == JSOP_EQ || op == JSOP_STRICTEQ)
-                          ? StringsEqualInfo
-                          : StringsNotEqualInfo)) {
-      return false;
-    }
+    callVM(masm, (op == JSOP_EQ || op == JSOP_STRICTEQ) ? StringsEqualInfo
+                                                        : StringsNotEqualInfo);
     stubFrame.leave(masm);
     masm.mov(ReturnReg, scratch);
   }
   masm.bind(&done);
   masm.tagValue(JSVAL_TYPE_BOOLEAN, scratch, output.valueReg());
   return true;
 }
 
@@ -980,19 +961,17 @@ bool BaselineCacheIRCompiler::callTypeUp
   masm.Push(val);
   masm.Push(TypedOrValueRegister(MIRType::Object, AnyRegister(obj)));
   masm.Push(ICStubReg);
 
   // Load previous frame pointer, push BaselineFrame*.
   masm.loadPtr(Address(BaselineFrameReg, 0), scratch);
   masm.pushBaselineFramePtr(scratch, scratch);
 
-  if (!callVM(masm, DoTypeUpdateFallbackInfo)) {
-    return false;
-  }
+  callVM(masm, DoTypeUpdateFallbackInfo);
 
   masm.PopRegsInMask(saveRegs);
 
   stubFrame.leave(masm);
 
   masm.bind(&done);
   return true;
 }
@@ -1675,19 +1654,17 @@ bool BaselineCacheIRCompiler::emitCallNa
 
   // Load the callee in the scratch register.
   masm.loadPtr(setterAddr, scratch);
 
   masm.Push(val);
   masm.Push(obj);
   masm.Push(scratch);
 
-  if (!callVM(masm, CallNativeSetterInfo)) {
-    return false;
-  }
+  callVM(masm, CallNativeSetterInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallScriptedSetter() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoScratchRegister scratch1(allocator, masm);
@@ -1779,19 +1756,17 @@ bool BaselineCacheIRCompiler::emitCallSe
 
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(obj);
 
-  if (!callVM(masm, SetArrayLengthInfo)) {
-    return false;
-  }
+  callVM(masm, SetArrayLengthInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallProxySet() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
@@ -1809,19 +1784,17 @@ bool BaselineCacheIRCompiler::emitCallPr
   // Load the jsid in the scratch register.
   masm.loadPtr(idAddr, scratch);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(scratch);
   masm.Push(obj);
 
-  if (!callVM(masm, ProxySetPropertyInfo)) {
-    return false;
-  }
+  callVM(masm, ProxySetPropertyInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallProxySetByValue() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
@@ -1844,19 +1817,17 @@ bool BaselineCacheIRCompiler::emitCallPr
   masm.loadPtr(Address(BaselineFrameReg, 0), obj);
   masm.loadPtr(Address(obj, scratchOffset), obj);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(idVal);
   masm.Push(obj);
 
-  if (!callVM(masm, ProxySetPropertyByValueInfo)) {
-    return false;
-  }
+  callVM(masm, ProxySetPropertyByValueInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallAddOrUpdateSparseElementHelper() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
@@ -1870,19 +1841,18 @@ bool BaselineCacheIRCompiler::emitCallAd
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(id);
   masm.Push(obj);
 
-  if (!callVM(masm, AddOrUpdateSparseElementHelperInfo)) {
-    return false;
-  }
+  callVM(masm, AddOrUpdateSparseElementHelperInfo);
+
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallGetSparseElementResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   Register id = allocator.useRegister(masm, reader.int32OperandId());
@@ -1891,19 +1861,18 @@ bool BaselineCacheIRCompiler::emitCallGe
   allocator.discardStack(masm);
 
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.Push(id);
   masm.Push(obj);
 
-  if (!callVM(masm, GetSparseElementHelperInfo)) {
-    return false;
-  }
+  callVM(masm, GetSparseElementHelperInfo);
+
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitMegamorphicSetElement() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   ValueOperand idVal = allocator.useValueRegister(masm, reader.valOperandId());
@@ -1926,19 +1895,17 @@ bool BaselineCacheIRCompiler::emitMegamo
   masm.loadPtr(Address(obj, scratchOffset), obj);
 
   masm.Push(Imm32(strict));
   masm.Push(TypedOrValueRegister(MIRType::Object, AnyRegister(obj)));
   masm.Push(val);
   masm.Push(idVal);
   masm.Push(obj);
 
-  if (!callVM(masm, SetObjectElementInfo)) {
-    return false;
-  }
+  callVM(masm, SetObjectElementInfo);
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitTypeMonitorResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   allocator.discardStack(masm);
@@ -2393,19 +2360,17 @@ bool BaselineCacheIRCompiler::emitCallSt
   allocator.discardStack(masm);
 
   AutoStubFrame stubFrame(*this);
   stubFrame.enter(masm, scratch);
 
   masm.push(rhs);
   masm.push(lhs);
 
-  if (!callVM(masm, ConcatStringsInfo)) {
-    return false;
-  }
+  callVM(masm, ConcatStringsInfo);
 
   masm.tagValue(JSVAL_TYPE_STRING, ReturnReg, output.valueReg());
 
   stubFrame.leave(masm);
   return true;
 }
 
 bool BaselineCacheIRCompiler::emitCallStringObjectConcatResult() {
@@ -2418,14 +2383,12 @@ bool BaselineCacheIRCompiler::emitCallSt
   // For the expression decompiler
   EmitRestoreTailCallReg(masm);
   masm.pushValue(lhs);
   masm.pushValue(rhs);
 
   masm.pushValue(rhs);
   masm.pushValue(lhs);
 
-  if (!tailCallVM(masm, DoConcatStringObjectInfo)) {
-    return false;
-  }
+  tailCallVM(masm, DoConcatStringObjectInfo);
 
   return true;
 }
--- a/js/src/jit/IonCacheIRCompiler.cpp
+++ b/js/src/jit/IonCacheIRCompiler.cpp
@@ -98,17 +98,17 @@ class MOZ_RAII IonCacheIRCompiler : publ
         readStubInt64(offset, StubField::Type::DOMExpandoGeneration);
     uint64_t* ptr =
         reinterpret_cast<uint64_t*>(stub_->stubDataStart() + offset);
     MOZ_ASSERT(*ptr == generation);
     return ptr;
   }
 
   void prepareVMCall(MacroAssembler& masm, const AutoSaveLiveRegisters&);
-  MOZ_MUST_USE bool callVM(MacroAssembler& masm, const VMFunction& fun);
+  void callVM(MacroAssembler& masm, const VMFunction& fun);
 
   MOZ_MUST_USE bool emitAddAndStoreSlotShared(CacheOp op);
 
   bool needsPostBarrier() const {
     return ic_->asSetPropertyIC()->needsPostBarrier();
   }
 
   void pushStubCodePointer() {
@@ -319,35 +319,34 @@ void IonCacheIRCompiler::prepareVMCall(M
   masm.Push(Imm32(descriptor));
   masm.Push(ImmPtr(GetReturnAddressToIonCode(cx_)));
 
 #ifdef DEBUG
   calledPrepareVMCall_ = true;
 #endif
 }
 
-bool IonCacheIRCompiler::callVM(MacroAssembler& masm, const VMFunction& fun) {
+void IonCacheIRCompiler::callVM(MacroAssembler& masm, const VMFunction& fun) {
   MOZ_ASSERT(calledPrepareVMCall_);
 
   TrampolinePtr code = cx_->runtime()->jitRuntime()->getVMWrapper(fun);
 
   uint32_t frameSize = fun.explicitStackSlots() * sizeof(void*);
   uint32_t descriptor = MakeFrameDescriptor(frameSize, FrameType::IonICCall,
                                             ExitFrameLayout::Size());
   masm.Push(Imm32(descriptor));
   masm.callJit(code);
 
   // Remove rest of the frame left on the stack. We remove the return address
-  // which is implicitly poped when returning.
+  // which is implicitly popped when returning.
   int framePop = sizeof(ExitFrameLayout) - sizeof(void*);
 
   // Pop arguments from framePushed.
   masm.implicitPop(frameSize + framePop);
   masm.freeStack(IonICCallFrameLayout::Size());
-  return true;
 }
 
 bool IonCacheIRCompiler::init() {
   if (!allocator.init()) {
     return false;
   }
 
   size_t numInputs = writer_.numInputOperands();
@@ -1141,19 +1140,17 @@ bool IonCacheIRCompiler::emitCallProxyGe
 
   allocator.discardStack(masm);
 
   prepareVMCall(masm, save);
 
   masm.Push(idVal);
   masm.Push(obj);
 
-  if (!callVM(masm, ProxyGetPropertyByValueInfo)) {
-    return false;
-  }
+  callVM(masm, ProxyGetPropertyByValueInfo);
 
   masm.storeCallResultValue(output);
   return true;
 }
 
 bool IonCacheIRCompiler::emitCallProxyHasPropResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
@@ -1166,23 +1163,19 @@ bool IonCacheIRCompiler::emitCallProxyHa
   allocator.discardStack(masm);
 
   prepareVMCall(masm, save);
 
   masm.Push(idVal);
   masm.Push(obj);
 
   if (hasOwn) {
-    if (!callVM(masm, ProxyHasOwnInfo)) {
-      return false;
-    }
+    callVM(masm, ProxyHasOwnInfo);
   } else {
-    if (!callVM(masm, ProxyHasInfo)) {
-      return false;
-    }
+    callVM(masm, ProxyHasInfo);
   }
 
   masm.storeCallResultValue(output);
   return true;
 }
 
 bool IonCacheIRCompiler::emitCallNativeGetElementResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
@@ -1195,19 +1188,17 @@ bool IonCacheIRCompiler::emitCallNativeG
   allocator.discardStack(masm);
 
   prepareVMCall(masm, save);
 
   masm.Push(index);
   masm.Push(TypedOrValueRegister(MIRType::Object, AnyRegister(obj)));
   masm.Push(obj);
 
-  if (!callVM(masm, NativeGetElementInfo)) {
-    return false;
-  }
+  callVM(masm, NativeGetElementInfo);
 
   masm.storeCallResultValue(output);
   return true;
 }
 
 bool IonCacheIRCompiler::emitLoadUnboxedPropertyResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoOutputRegister output(*this);
@@ -1296,19 +1287,17 @@ bool IonCacheIRCompiler::emitCallStringS
 
   prepareVMCall(masm, save);
 
   masm.Push(str);
   masm.Push(sep);
   masm.Push(ImmGCPtr(group));
   masm.Push(Imm32(INT32_MAX));
 
-  if (!callVM(masm, StringSplitHelperInfo)) {
-    return false;
-  }
+  callVM(masm, StringSplitHelperInfo);
 
   masm.storeCallResultValue(output);
   return true;
 }
 
 bool IonCacheIRCompiler::emitCompareStringResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
@@ -1326,21 +1315,18 @@ bool IonCacheIRCompiler::emitCompareStri
 
   masm.jump(&done);
   masm.bind(&slow);
 
   prepareVMCall(masm, save);
   masm.Push(right);
   masm.Push(left);
 
-  if (!callVM(masm, (op == JSOP_EQ || op == JSOP_STRICTEQ)
-                        ? StringsEqualInfo
-                        : StringsNotEqualInfo)) {
-    return false;
-  }
+  callVM(masm, (op == JSOP_EQ || op == JSOP_STRICTEQ) ? StringsEqualInfo
+                                                      : StringsNotEqualInfo);
 
   masm.storeCallBoolResult(output.typedReg().gpr());
   masm.bind(&done);
   return true;
 }
 
 static bool GroupHasPropertyTypes(ObjectGroup* group, jsid* id, Value* v) {
   AutoUnsafeCallWithABI unsafe;
@@ -2198,17 +2184,18 @@ bool IonCacheIRCompiler::emitCallSetArra
 
   allocator.discardStack(masm);
   prepareVMCall(masm, save);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(obj);
 
-  return callVM(masm, SetArrayLengthInfo);
+  callVM(masm, SetArrayLengthInfo);
+  return true;
 }
 
 bool IonCacheIRCompiler::emitCallProxySet() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
 
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   ConstantOrRegister val =
@@ -2221,17 +2208,18 @@ bool IonCacheIRCompiler::emitCallProxySe
   allocator.discardStack(masm);
   prepareVMCall(masm, save);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(id, scratch);
   masm.Push(obj);
 
-  return callVM(masm, ProxySetPropertyInfo);
+  callVM(masm, ProxySetPropertyInfo);
+  return true;
 }
 
 bool IonCacheIRCompiler::emitCallProxySetByValue() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
 
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   ConstantOrRegister idVal =
@@ -2243,17 +2231,18 @@ bool IonCacheIRCompiler::emitCallProxySe
   allocator.discardStack(masm);
   prepareVMCall(masm, save);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(idVal);
   masm.Push(obj);
 
-  return callVM(masm, ProxySetPropertyByValueInfo);
+  callVM(masm, ProxySetPropertyByValueInfo);
+  return true;
 }
 
 bool IonCacheIRCompiler::emitCallAddOrUpdateSparseElementHelper() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
 
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   Register id = allocator.useRegister(masm, reader.int32OperandId());
@@ -2263,35 +2252,34 @@ bool IonCacheIRCompiler::emitCallAddOrUp
   allocator.discardStack(masm);
   prepareVMCall(masm, save);
 
   masm.Push(Imm32(strict));
   masm.Push(val);
   masm.Push(id);
   masm.Push(obj);
 
-  return callVM(masm, AddOrUpdateSparseElementHelperInfo);
+  callVM(masm, AddOrUpdateSparseElementHelperInfo);
+  return true;
 }
 
 bool IonCacheIRCompiler::emitCallGetSparseElementResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
   AutoOutputRegister output(*this);
 
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   Register id = allocator.useRegister(masm, reader.int32OperandId());
 
   allocator.discardStack(masm);
   prepareVMCall(masm, save);
   masm.Push(id);
   masm.Push(obj);
 
-  if (!callVM(masm, GetSparseElementHelperInfo)) {
-    return false;
-  }
+  callVM(masm, GetSparseElementHelperInfo);
 
   masm.storeCallResultValue(output);
   return true;
 }
 
 bool IonCacheIRCompiler::emitMegamorphicSetElement() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoSaveLiveRegisters save(*this);
@@ -2307,17 +2295,18 @@ bool IonCacheIRCompiler::emitMegamorphic
   prepareVMCall(masm, save);
 
   masm.Push(Imm32(strict));
   masm.Push(TypedOrValueRegister(MIRType::Object, AnyRegister(obj)));
   masm.Push(val);
   masm.Push(idVal);
   masm.Push(obj);
 
-  return callVM(masm, SetObjectElementInfo);
+  callVM(masm, SetObjectElementInfo);
+  return true;
 }
 
 bool IonCacheIRCompiler::emitLoadTypedObjectResult() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   AutoOutputRegister output(*this);
   Register obj = allocator.useRegister(masm, reader.objOperandId());
   AutoScratchRegister scratch1(allocator, masm);
   AutoScratchRegister scratch2(allocator, masm);
@@ -2585,19 +2574,17 @@ bool IonCacheIRCompiler::emitCallStringC
 
   allocator.discardStack(masm);
 
   prepareVMCall(masm, save);
 
   masm.Push(rhs);
   masm.Push(lhs);
 
-  if (!callVM(masm, ConcatStringsInfo)) {
-    return false;
-  }
+  callVM(masm, ConcatStringsInfo);
 
   masm.tagValue(JSVAL_TYPE_STRING, ReturnReg, output.valueReg());
   return true;
 }
 
 typedef bool (*DoConcatStringObjectFn)(JSContext*, HandleValue, HandleValue,
                                        MutableHandleValue);
 const VMFunction DoIonConcatStringObjectInfo =
@@ -2613,15 +2600,13 @@ bool IonCacheIRCompiler::emitCallStringO
   ValueOperand rhs = allocator.useValueRegister(masm, reader.valOperandId());
 
   allocator.discardStack(masm);
 
   prepareVMCall(masm, save);
   masm.Push(rhs);
   masm.Push(lhs);
 
-  if (!callVM(masm, DoIonConcatStringObjectInfo)) {
-    return false;
-  }
+  callVM(masm, DoIonConcatStringObjectInfo);
 
   masm.storeCallResultValue(output);
   return true;
 }