Bug 1542740: Convert HasPropIRGenerator to use AttachDecision r=mgaudet
authorIain Ireland <iireland@mozilla.com>
Fri, 26 Apr 2019 14:28:36 +0000
changeset 471524 448eb3cd7fdf864db3a331fc1dd405ba19d3f316
parent 471523 b9871f6c9a35abaf847e01d4b902bb57b87ac3a4
child 471525 1e1017253de570f2440de2dc2ccbfe2b6646ae60
push id84143
push useriireland@mozilla.com
push dateFri, 26 Apr 2019 15:09:46 +0000
treeherderautoland@85d43344501f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmgaudet
bugs1542740
milestone68.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 1542740: Convert HasPropIRGenerator to use AttachDecision r=mgaudet Differential Revision: https://phabricator.services.mozilla.com/D27301
js/src/jit/BaselineIC.cpp
js/src/jit/CacheIR.cpp
js/src/jit/CacheIR.h
js/src/jit/IonIC.cpp
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -2589,19 +2589,19 @@ bool DoInFallback(JSContext* cx, Baselin
 
   FallbackICSpew(cx, stub, "In");
 
   if (!objValue.isObject()) {
     ReportInNotObjectError(cx, key, -2, objValue, -1);
     return false;
   }
 
-  TryAttachStubOld<HasPropIRGenerator>("In", cx, frame, stub,
-                                       BaselineCacheIRStubKind::Regular,
-                                       CacheKind::In, key, objValue);
+  TryAttachStub<HasPropIRGenerator>("In", cx, frame, stub,
+                                    BaselineCacheIRStubKind::Regular,
+                                    CacheKind::In, key, objValue);
 
   RootedObject obj(cx, &objValue.toObject());
   bool cond = false;
   if (!OperatorIn(cx, key, obj, &cond)) {
     return false;
   }
   res.setBoolean(cond);
 
@@ -2632,19 +2632,19 @@ bool FallbackICCodeCompiler::emit_In() {
 
 bool DoHasOwnFallback(JSContext* cx, BaselineFrame* frame,
                       ICHasOwn_Fallback* stub, HandleValue keyValue,
                       HandleValue objValue, MutableHandleValue res) {
   stub->incrementEnteredCount();
 
   FallbackICSpew(cx, stub, "HasOwn");
 
-  TryAttachStubOld<HasPropIRGenerator>("HasOwn", cx, frame, stub,
-                                       BaselineCacheIRStubKind::Regular,
-                                       CacheKind::HasOwn, keyValue, objValue);
+  TryAttachStub<HasPropIRGenerator>("HasOwn", cx, frame, stub,
+                                    BaselineCacheIRStubKind::Regular,
+                                    CacheKind::HasOwn, keyValue, objValue);
 
   bool found;
   if (!HasOwnProperty(cx, objValue, keyValue, &found)) {
     return false;
   }
 
   res.setBoolean(found);
   return true;
--- a/js/src/jit/CacheIR.cpp
+++ b/js/src/jit/CacheIR.cpp
@@ -2776,52 +2776,54 @@ void BindNameIRGenerator::trackAttached(
 }
 
 HasPropIRGenerator::HasPropIRGenerator(JSContext* cx, HandleScript script,
                                        jsbytecode* pc, ICState::Mode mode,
                                        CacheKind cacheKind, HandleValue idVal,
                                        HandleValue val)
     : IRGenerator(cx, script, pc, cacheKind, mode), val_(val), idVal_(idVal) {}
 
-bool HasPropIRGenerator::tryAttachDense(HandleObject obj, ObjOperandId objId,
-                                        uint32_t index,
-                                        Int32OperandId indexId) {
+AttachDecision HasPropIRGenerator::tryAttachDense(HandleObject obj,
+                                                  ObjOperandId objId,
+                                                  uint32_t index,
+                                                  Int32OperandId indexId) {
   if (!obj->isNative()) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   NativeObject* nobj = &obj->as<NativeObject>();
   if (!nobj->containsDenseElement(index)) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   // Guard shape to ensure object class is NativeObject.
   TestMatchingNativeReceiver(writer, nobj, objId);
   writer.loadDenseElementExistsResult(objId, indexId);
   writer.returnFromIC();
 
   trackAttached("DenseHasProp");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachDenseHole(HandleObject obj,
-                                            ObjOperandId objId, uint32_t index,
-                                            Int32OperandId indexId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachDenseHole(HandleObject obj,
+                                                      ObjOperandId objId,
+                                                      uint32_t index,
+                                                      Int32OperandId indexId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   if (!obj->isNative()) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   NativeObject* nobj = &obj->as<NativeObject>();
   if (nobj->containsDenseElement(index)) {
-    return false;
+    return AttachDecision::NoAction;
   }
   if (!CanAttachDenseElementHole(nobj, hasOwn)) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   // Guard shape to ensure class is NativeObject and to prevent non-dense
   // elements being added. Also ensures prototype doesn't change if dynamic
   // checks aren't emitted.
   TestMatchingNativeReceiver(writer, nobj, objId);
 
   // Generate prototype guards if needed. This includes monitoring that
@@ -2830,32 +2832,33 @@ bool HasPropIRGenerator::tryAttachDenseH
     GeneratePrototypeHoleGuards(writer, nobj, objId,
                                 /* alwaysGuardFirstProto = */ false);
   }
 
   writer.loadDenseElementHoleExistsResult(objId, indexId);
   writer.returnFromIC();
 
   trackAttached("DenseHasPropHole");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachSparse(HandleObject obj, ObjOperandId objId,
-                                         Int32OperandId indexId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachSparse(HandleObject obj,
+                                                   ObjOperandId objId,
+                                                   Int32OperandId indexId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   if (!obj->isNative()) {
-    return false;
+    return AttachDecision::NoAction;
   }
   if (!obj->as<NativeObject>().isIndexed()) {
-    return false;
+    return AttachDecision::NoAction;
   }
   if (!CanAttachDenseElementHole(&obj->as<NativeObject>(), hasOwn,
                                  /* allowIndexedReceiver = */ true)) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   // Guard that this is a native object.
   writer.guardIsNativeObject(objId);
 
   // Generate prototype guards if needed. This includes monitoring that
   // properties were not added in the chain.
   if (!hasOwn) {
@@ -2864,259 +2867,239 @@ bool HasPropIRGenerator::tryAttachSparse
   }
 
   // Because of the prototype guard we know that the prototype chain
   // does not include any dense or sparse (i.e indexed) properties.
   writer.callObjectHasSparseElementResult(objId, indexId);
   writer.returnFromIC();
 
   trackAttached("Sparse");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachNamedProp(HandleObject obj,
-                                            ObjOperandId objId, HandleId key,
-                                            ValOperandId keyId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachNamedProp(HandleObject obj,
+                                                      ObjOperandId objId,
+                                                      HandleId key,
+                                                      ValOperandId keyId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   JSObject* holder = nullptr;
   PropertyResult prop;
 
   if (hasOwn) {
     if (!LookupOwnPropertyPure(cx_, obj, key, &prop)) {
-      return false;
+      return AttachDecision::NoAction;
     }
 
     holder = obj;
   } else {
     if (!LookupPropertyPure(cx_, obj, key, &holder, &prop)) {
-      return false;
+      return AttachDecision::NoAction;
     }
   }
   if (!prop) {
-    return false;
-  }
-
-  if (tryAttachMegamorphic(objId, keyId)) {
-    return true;
-  }
-  if (tryAttachNative(obj, objId, key, keyId, prop, holder)) {
-    return true;
-  }
-  if (tryAttachTypedObject(obj, objId, key, keyId)) {
-    return true;
-  }
-
-  return false;
-}
-
-bool HasPropIRGenerator::tryAttachMegamorphic(ObjOperandId objId,
-                                              ValOperandId keyId) {
+    return AttachDecision::NoAction;
+  }
+
+  TRY_ATTACH(tryAttachMegamorphic(objId, keyId));
+  TRY_ATTACH(tryAttachNative(obj, objId, key, keyId, prop, holder));
+  TRY_ATTACH(tryAttachTypedObject(obj, objId, key, keyId));
+
+  return AttachDecision::NoAction;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachMegamorphic(ObjOperandId objId,
+                                                        ValOperandId keyId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   if (mode_ != ICState::Mode::Megamorphic) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   writer.megamorphicHasPropResult(objId, keyId, hasOwn);
   writer.returnFromIC();
   trackAttached("MegamorphicHasProp");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachNative(JSObject* obj, ObjOperandId objId,
-                                         jsid key, ValOperandId keyId,
-                                         PropertyResult prop,
-                                         JSObject* holder) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachNative(JSObject* obj,
+                                                   ObjOperandId objId, jsid key,
+                                                   ValOperandId keyId,
+                                                   PropertyResult prop,
+                                                   JSObject* holder) {
   if (!prop.isNativeProperty()) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   if (!IsCacheableProtoChain(obj, holder)) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   Maybe<ObjOperandId> tempId;
   emitIdGuard(keyId, key);
   EmitReadSlotGuard(writer, obj, holder, objId, &tempId);
   writer.loadBooleanResult(true);
   writer.returnFromIC();
 
   trackAttached("NativeHasProp");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachTypedArray(HandleObject obj,
-                                             ObjOperandId objId,
-                                             Int32OperandId indexId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachTypedArray(HandleObject obj,
+                                                       ObjOperandId objId,
+                                                       Int32OperandId indexId) {
   if (!obj->is<TypedArrayObject>() && !IsPrimitiveArrayTypedObject(obj)) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   TypedThingLayout layout = GetTypedThingLayout(obj->getClass());
 
   if (IsPrimitiveArrayTypedObject(obj)) {
     writer.guardGroupForLayout(objId, obj->group());
   } else {
     writer.guardShapeForClass(objId, obj->as<TypedArrayObject>().shape());
   }
 
   writer.loadTypedElementExistsResult(objId, indexId, layout);
 
   writer.returnFromIC();
 
   trackAttached("TypedArrayObject");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachTypedObject(JSObject* obj, ObjOperandId objId,
-                                              jsid key, ValOperandId keyId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachTypedObject(JSObject* obj,
+                                                        ObjOperandId objId,
+                                                        jsid key,
+                                                        ValOperandId keyId) {
   if (!obj->is<TypedObject>()) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   if (!obj->as<TypedObject>().typeDescr().hasProperty(cx_->names(), key)) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   emitIdGuard(keyId, key);
   writer.guardGroupForLayout(objId, obj->group());
   writer.loadBooleanResult(true);
   writer.returnFromIC();
 
   trackAttached("TypedObjectHasProp");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachSlotDoesNotExist(JSObject* obj,
-                                                   ObjOperandId objId, jsid key,
-                                                   ValOperandId keyId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachSlotDoesNotExist(
+    JSObject* obj, ObjOperandId objId, jsid key, ValOperandId keyId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   emitIdGuard(keyId, key);
   if (hasOwn) {
     TestMatchingReceiver(writer, obj, objId);
   } else {
     Maybe<ObjOperandId> tempId;
     EmitReadSlotGuard(writer, obj, nullptr, objId, &tempId);
   }
   writer.loadBooleanResult(false);
   writer.returnFromIC();
 
   trackAttached("DoesNotExist");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachDoesNotExist(HandleObject obj,
-                                               ObjOperandId objId, HandleId key,
-                                               ValOperandId keyId) {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachDoesNotExist(HandleObject obj,
+                                                         ObjOperandId objId,
+                                                         HandleId key,
+                                                         ValOperandId keyId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   // Check that property doesn't exist on |obj| or it's prototype chain. These
   // checks allow Native/Typed objects with a NativeObject prototype
-  // chain. They return false if unknown such as resolve hooks or proxies.
+  // chain. They return NoAction if unknown such as resolve hooks or proxies.
   if (hasOwn) {
     if (!CheckHasNoSuchOwnProperty(cx_, obj, key)) {
-      return false;
+      return AttachDecision::NoAction;
     }
   } else {
     if (!CheckHasNoSuchProperty(cx_, obj, key)) {
-      return false;
+      return AttachDecision::NoAction;
     }
   }
 
-  if (tryAttachMegamorphic(objId, keyId)) {
-    return true;
-  }
-  if (tryAttachSlotDoesNotExist(obj, objId, key, keyId)) {
-    return true;
-  }
-
-  return false;
-}
-
-bool HasPropIRGenerator::tryAttachProxyElement(HandleObject obj,
-                                               ObjOperandId objId,
-                                               ValOperandId keyId) {
+  TRY_ATTACH(tryAttachMegamorphic(objId, keyId));
+  TRY_ATTACH(tryAttachSlotDoesNotExist(obj, objId, key, keyId));
+
+  return AttachDecision::NoAction;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachProxyElement(HandleObject obj,
+                                                         ObjOperandId objId,
+                                                         ValOperandId keyId) {
   bool hasOwn = (cacheKind_ == CacheKind::HasOwn);
 
   if (!obj->is<ProxyObject>()) {
-    return false;
+    return AttachDecision::NoAction;
   }
 
   writer.guardIsProxy(objId);
   writer.callProxyHasPropResult(objId, keyId, hasOwn);
   writer.returnFromIC();
 
   trackAttached("ProxyHasProp");
-  return true;
-}
-
-bool HasPropIRGenerator::tryAttachStub() {
+  return AttachDecision::Attach;
+}
+
+AttachDecision HasPropIRGenerator::tryAttachStub() {
   MOZ_ASSERT(cacheKind_ == CacheKind::In || cacheKind_ == CacheKind::HasOwn);
 
   AutoAssertNoPendingException aanpe(cx_);
 
   // NOTE: Argument order is PROPERTY, OBJECT
   ValOperandId keyId(writer.setInputOperandId(0));
   ValOperandId valId(writer.setInputOperandId(1));
 
   if (!val_.isObject()) {
     trackAttached(IRGenerator::NotAttached);
-    return false;
+    return AttachDecision::NoAction;
   }
   RootedObject obj(cx_, &val_.toObject());
   ObjOperandId objId = writer.guardIsObject(valId);
 
   // Optimize Proxies
-  if (tryAttachProxyElement(obj, objId, keyId)) {
-    return true;
-  }
+  TRY_ATTACH(tryAttachProxyElement(obj, objId, keyId));
 
   RootedId id(cx_);
   bool nameOrSymbol;
   if (!ValueToNameOrSymbolId(cx_, idVal_, &id, &nameOrSymbol)) {
     cx_->clearPendingException();
-    return false;
+    return AttachDecision::NoAction;
   }
 
   if (nameOrSymbol) {
-    if (tryAttachNamedProp(obj, objId, id, keyId)) {
-      return true;
-    }
-    if (tryAttachDoesNotExist(obj, objId, id, keyId)) {
-      return true;
-    }
+    TRY_ATTACH(tryAttachNamedProp(obj, objId, id, keyId));
+    TRY_ATTACH(tryAttachDoesNotExist(obj, objId, id, keyId));
 
     trackAttached(IRGenerator::NotAttached);
-    return false;
+    return AttachDecision::NoAction;
   }
 
   uint32_t index;
   Int32OperandId indexId;
   if (maybeGuardInt32Index(idVal_, keyId, &index, &indexId)) {
-    if (tryAttachDense(obj, objId, index, indexId)) {
-      return true;
-    }
-    if (tryAttachDenseHole(obj, objId, index, indexId)) {
-      return true;
-    }
-    if (tryAttachTypedArray(obj, objId, indexId)) {
-      return true;
-    }
-    if (tryAttachSparse(obj, objId, indexId)) {
-      return true;
-    }
+    TRY_ATTACH(tryAttachDense(obj, objId, index, indexId));
+    TRY_ATTACH(tryAttachDenseHole(obj, objId, index, indexId));
+    TRY_ATTACH(tryAttachTypedArray(obj, objId, indexId));
+    TRY_ATTACH(tryAttachSparse(obj, objId, indexId));
 
     trackAttached(IRGenerator::NotAttached);
-    return false;
+    return AttachDecision::NoAction;
   }
 
   trackAttached(IRGenerator::NotAttached);
-  return false;
+  return AttachDecision::NoAction;
 }
 
 void HasPropIRGenerator::trackAttached(const char* name) {
 #ifdef JS_CACHEIR_SPEW
   if (const CacheIRSpewer::Guard& sp = CacheIRSpewer::Guard(*this, name)) {
     sp.valueProperty("base", val_);
     sp.valueProperty("property", idVal_);
   }
--- a/js/src/jit/CacheIR.h
+++ b/js/src/jit/CacheIR.h
@@ -2256,52 +2256,52 @@ class MOZ_RAII SetPropIRGenerator : publ
 };
 
 // HasPropIRGenerator generates CacheIR for a HasProp IC. Used for
 // CacheKind::In / CacheKind::HasOwn.
 class MOZ_RAII HasPropIRGenerator : public IRGenerator {
   HandleValue val_;
   HandleValue idVal_;
 
-  bool tryAttachDense(HandleObject obj, ObjOperandId objId, uint32_t index,
-                      Int32OperandId indexId);
-  bool tryAttachDenseHole(HandleObject obj, ObjOperandId objId, uint32_t index,
-                          Int32OperandId indexId);
-  bool tryAttachTypedArray(HandleObject obj, ObjOperandId objId,
-                           Int32OperandId indexId);
-  bool tryAttachSparse(HandleObject obj, ObjOperandId objId,
-                       Int32OperandId indexId);
-  bool tryAttachNamedProp(HandleObject obj, ObjOperandId objId, HandleId key,
-                          ValOperandId keyId);
-  bool tryAttachMegamorphic(ObjOperandId objId, ValOperandId keyId);
-  bool tryAttachNative(JSObject* obj, ObjOperandId objId, jsid key,
-                       ValOperandId keyId, PropertyResult prop,
-                       JSObject* holder);
-  bool tryAttachUnboxed(JSObject* obj, ObjOperandId objId, jsid key,
-                        ValOperandId keyId);
-  bool tryAttachUnboxedExpando(JSObject* obj, ObjOperandId objId, jsid key,
-                               ValOperandId keyId);
-  bool tryAttachTypedObject(JSObject* obj, ObjOperandId objId, jsid key,
-                            ValOperandId keyId);
-  bool tryAttachSlotDoesNotExist(JSObject* obj, ObjOperandId objId, jsid key,
-                                 ValOperandId keyId);
-  bool tryAttachDoesNotExist(HandleObject obj, ObjOperandId objId, HandleId key,
-                             ValOperandId keyId);
-  bool tryAttachProxyElement(HandleObject obj, ObjOperandId objId,
-                             ValOperandId keyId);
+  AttachDecision tryAttachDense(HandleObject obj, ObjOperandId objId,
+                                uint32_t index, Int32OperandId indexId);
+  AttachDecision tryAttachDenseHole(HandleObject obj, ObjOperandId objId,
+                                    uint32_t index, Int32OperandId indexId);
+  AttachDecision tryAttachTypedArray(HandleObject obj, ObjOperandId objId,
+                                     Int32OperandId indexId);
+  AttachDecision tryAttachSparse(HandleObject obj, ObjOperandId objId,
+                                 Int32OperandId indexId);
+  AttachDecision tryAttachNamedProp(HandleObject obj, ObjOperandId objId,
+                                    HandleId key, ValOperandId keyId);
+  AttachDecision tryAttachMegamorphic(ObjOperandId objId, ValOperandId keyId);
+  AttachDecision tryAttachNative(JSObject* obj, ObjOperandId objId, jsid key,
+                                 ValOperandId keyId, PropertyResult prop,
+                                 JSObject* holder);
+  AttachDecision tryAttachUnboxed(JSObject* obj, ObjOperandId objId, jsid key,
+                                  ValOperandId keyId);
+  AttachDecision tryAttachUnboxedExpando(JSObject* obj, ObjOperandId objId,
+                                         jsid key, ValOperandId keyId);
+  AttachDecision tryAttachTypedObject(JSObject* obj, ObjOperandId objId,
+                                      jsid key, ValOperandId keyId);
+  AttachDecision tryAttachSlotDoesNotExist(JSObject* obj, ObjOperandId objId,
+                                           jsid key, ValOperandId keyId);
+  AttachDecision tryAttachDoesNotExist(HandleObject obj, ObjOperandId objId,
+                                       HandleId key, ValOperandId keyId);
+  AttachDecision tryAttachProxyElement(HandleObject obj, ObjOperandId objId,
+                                       ValOperandId keyId);
 
   void trackAttached(const char* name);
 
  public:
   // NOTE: Argument order is PROPERTY, OBJECT
   HasPropIRGenerator(JSContext* cx, HandleScript script, jsbytecode* pc,
                      ICState::Mode mode, CacheKind cacheKind, HandleValue idVal,
                      HandleValue val);
 
-  bool tryAttachStub();
+  AttachDecision tryAttachStub();
 };
 
 class MOZ_RAII InstanceOfIRGenerator : public IRGenerator {
   HandleValue lhsVal_;
   HandleObject rhsObj_;
 
   void trackAttached(const char* name);
 
--- a/js/src/jit/IonIC.cpp
+++ b/js/src/jit/IonIC.cpp
@@ -465,17 +465,17 @@ JSObject* IonGetIteratorIC::update(JSCon
 }
 
 /* static */
 bool IonHasOwnIC::update(JSContext* cx, HandleScript outerScript,
                          IonHasOwnIC* ic, HandleValue val, HandleValue idVal,
                          int32_t* res) {
   IonScript* ionScript = outerScript->ionScript();
 
-  TryAttachIonStubOld<HasPropIRGenerator, IonHasOwnIC>(
+  TryAttachIonStub<HasPropIRGenerator, IonHasOwnIC>(
       cx, ic, ionScript, CacheKind::HasOwn, idVal, val);
 
   bool found;
   if (!HasOwnProperty(cx, val, idVal, &found)) {
     return false;
   }
 
   *res = found;
@@ -483,18 +483,18 @@ bool IonHasOwnIC::update(JSContext* cx, 
 }
 
 /* static */
 bool IonInIC::update(JSContext* cx, HandleScript outerScript, IonInIC* ic,
                      HandleValue key, HandleObject obj, bool* res) {
   IonScript* ionScript = outerScript->ionScript();
   RootedValue objV(cx, ObjectValue(*obj));
 
-  TryAttachIonStubOld<HasPropIRGenerator, IonInIC>(cx, ic, ionScript,
-                                                   CacheKind::In, key, objV);
+  TryAttachIonStub<HasPropIRGenerator, IonInIC>(cx, ic, ionScript,
+                                                CacheKind::In, key, objV);
 
   return OperatorIn(cx, key, obj, res);
 }
 /* static */
 bool IonInstanceOfIC::update(JSContext* cx, HandleScript outerScript,
                              IonInstanceOfIC* ic, HandleValue lhs,
                              HandleObject rhs, bool* res) {
   IonScript* ionScript = outerScript->ionScript();