Bug 1534285 - Make spacing between member functions in CacheIR.h consistent. r=mgaudet
authorKaran Sapolia <sapoliakaran@gmail.com>
Tue, 02 Jul 2019 12:55:33 +0000
changeset 543785 69309ca1e67f5f169deaa05735241497a3deba8f
parent 543784 baa4919fcae348909c9f09b64fe3883578c526a1
child 543786 1cdac03c50cd9e75a45153c691309f590306aa6c
push id2131
push userffxbld-merge
push dateMon, 26 Aug 2019 18:30:20 +0000
treeherdermozilla-release@b19ffb3ca153 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmgaudet
bugs1534285
milestone69.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 1534285 - Make spacing between member functions in CacheIR.h consistent. r=mgaudet Differential Revision: https://phabricator.services.mozilla.com/D35087
js/src/jit/CacheIR.h
--- a/js/src/jit/CacheIR.h
+++ b/js/src/jit/CacheIR.h
@@ -421,20 +421,22 @@ class StubField {
 
     Limit
   };
 
   static bool sizeIsWord(Type type) {
     MOZ_ASSERT(type != Type::Limit);
     return type < Type::First64BitType;
   }
+
   static bool sizeIsInt64(Type type) {
     MOZ_ASSERT(type != Type::Limit);
     return type >= Type::First64BitType;
   }
+
   static size_t sizeInBytes(Type type) {
     if (sizeIsWord(type)) {
       return sizeof(uintptr_t);
     }
     MOZ_ASSERT(sizeIsInt64(type));
     return sizeof(int64_t);
   }
 
@@ -721,16 +723,17 @@ class MOZ_RAII CacheIRWriter : public JS
       offset = stubDataSize_ / sizeof(uintptr_t);
       buffer_.writeByte(offset);
       stubDataSize_ = newStubDataSize;
     } else {
       tooLarge_ = true;
     }
     return offset;
   }
+
   void reuseStubField(FieldOffset offset) {
     MOZ_ASSERT(offset < stubDataSize_ / sizeof(uintptr_t));
     buffer_.writeByte(offset);
   }
 
   CacheIRWriter(const CacheIRWriter&) = delete;
   CacheIRWriter& operator=(const CacheIRWriter&) = delete;
 
@@ -774,322 +777,381 @@ class MOZ_RAII CacheIRWriter : public JS
   bool stubDataEqualsMaybeUpdate(uint8_t* stubData, bool* updated) const;
 
   bool operandIsDead(uint32_t operandId, uint32_t currentInstruction) const {
     if (operandId >= operandLastUsed_.length()) {
       return false;
     }
     return currentInstruction > operandLastUsed_[operandId];
   }
+
   const uint8_t* codeStart() const {
     MOZ_ASSERT(!failed());
     return buffer_.buffer();
   }
+
   const uint8_t* codeEnd() const {
     MOZ_ASSERT(!failed());
     return buffer_.buffer() + buffer_.length();
   }
+
   uint32_t codeLength() const {
     MOZ_ASSERT(!failed());
     return buffer_.length();
   }
 
   // This should not be used when compiling Baseline code, as Baseline code
   // shouldn't bake in stub values.
   StubField readStubFieldForIon(uint32_t offset, StubField::Type type) const;
 
   ObjOperandId guardIsObject(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsObject, val);
     return ObjOperandId(val.id());
   }
+
   Int32OperandId guardIsBoolean(ValOperandId val) {
     Int32OperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardIsBoolean, val);
     writeOperandId(res);
     return res;
   }
+
   StringOperandId guardIsString(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsString, val);
     return StringOperandId(val.id());
   }
+
   SymbolOperandId guardIsSymbol(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsSymbol, val);
     return SymbolOperandId(val.id());
   }
+
   BigIntOperandId guardIsBigInt(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsBigInt, val);
     return BigIntOperandId(val.id());
   }
+
   Int32OperandId guardIsInt32(ValOperandId val) {
     Int32OperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardIsInt32, val);
     writeOperandId(res);
     return res;
   }
+
   Int32OperandId guardIsInt32Index(ValOperandId val) {
     Int32OperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardIsInt32Index, val);
     writeOperandId(res);
     return res;
   }
+
   void guardIsNumber(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsNumber, val);
   }
+
   void guardType(ValOperandId val, ValueType type) {
     writeOpWithOperandId(CacheOp::GuardType, val);
     static_assert(sizeof(type) == sizeof(uint8_t),
                   "JS::ValueType should fit in a byte");
     buffer_.writeByte(uint32_t(type));
   }
+
   void guardIsObjectOrNull(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsObjectOrNull, val);
   }
+
   void guardIsNullOrUndefined(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsNullOrUndefined, val);
   }
+
   void guardIsNotNullOrUndefined(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsNotNullOrUndefined, val);
   }
+
   void guardIsNull(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsNull, val);
   }
+
   void guardIsUndefined(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsUndefined, val);
   }
+
   void guardShape(ObjOperandId obj, Shape* shape) {
     MOZ_ASSERT(shape);
     writeOpWithOperandId(CacheOp::GuardShape, obj);
     addStubField(uintptr_t(shape), StubField::Type::Shape);
   }
+
   void guardShapeForClass(ObjOperandId obj, Shape* shape) {
     // Guard shape to ensure that object class is unchanged. This is true
     // for all shapes.
     guardShape(obj, shape);
   }
+
   void guardShapeForOwnProperties(ObjOperandId obj, Shape* shape) {
     // Guard shape to detect changes to (non-dense) own properties. This
     // also implies |guardShapeForClass|.
     MOZ_ASSERT(shape->getObjectClass()->isNative());
     guardShape(obj, shape);
   }
+
   void guardXrayExpandoShapeAndDefaultProto(ObjOperandId obj,
                                             JSObject* shapeWrapper) {
     assertSameCompartment(shapeWrapper);
     writeOpWithOperandId(CacheOp::GuardXrayExpandoShapeAndDefaultProto, obj);
     buffer_.writeByte(uint32_t(!!shapeWrapper));
     addStubField(uintptr_t(shapeWrapper), StubField::Type::JSObject);
   }
+
   // Guard rhs[slot] == prototypeObject
   void guardFunctionPrototype(ObjOperandId rhs, uint32_t slot,
                               ObjOperandId protoId) {
     writeOpWithOperandId(CacheOp::GuardFunctionPrototype, rhs);
     writeOperandId(protoId);
     addStubField(slot, StubField::Type::RawWord);
   }
+
   void guardNoAllocationMetadataBuilder() {
     writeOp(CacheOp::GuardNoAllocationMetadataBuilder);
   }
+
   void guardObjectGroupNotPretenured(ObjectGroup* group) {
     writeOp(CacheOp::GuardObjectGroupNotPretenured);
     addStubField(uintptr_t(group), StubField::Type::ObjectGroup);
   }
+
   void guardFunctionHasJitEntry(ObjOperandId fun, bool isConstructing) {
     writeOpWithOperandId(CacheOp::GuardFunctionHasJitEntry, fun);
     buffer_.writeByte(isConstructing);
   }
+
   void guardNotClassConstructor(ObjOperandId fun) {
     writeOpWithOperandId(CacheOp::GuardNotClassConstructor, fun);
   }
 
  public:
   // Use (or create) a specialization below to clarify what constaint the
   // group guard is implying.
   void guardGroup(ObjOperandId obj, ObjectGroup* group) {
     writeOpWithOperandId(CacheOp::GuardGroup, obj);
     addStubField(uintptr_t(group), StubField::Type::ObjectGroup);
   }
+
   void guardGroupForProto(ObjOperandId obj, ObjectGroup* group) {
     MOZ_ASSERT(!group->hasUncacheableProto());
     guardGroup(obj, group);
   }
+
   void guardGroupForTypeBarrier(ObjOperandId obj, ObjectGroup* group) {
     // Typesets will always be a super-set of any typesets previously seen
     // for this group. If the type/group of a value being stored to a
     // property in this group is not known, a TypeUpdate IC chain should be
     // used as well.
     guardGroup(obj, group);
   }
+
   void guardGroupForLayout(ObjOperandId obj, ObjectGroup* group) {
     // NOTE: Comment in guardGroupForTypeBarrier also applies.
     MOZ_ASSERT(IsTypedObjectClass(group->clasp()));
     guardGroup(obj, group);
   }
+
   void guardProto(ObjOperandId obj, JSObject* proto) {
     assertSameCompartment(proto);
     writeOpWithOperandId(CacheOp::GuardProto, obj);
     addStubField(uintptr_t(proto), StubField::Type::JSObject);
   }
+
   void guardClass(ObjOperandId obj, GuardClassKind kind) {
     static_assert(sizeof(GuardClassKind) == sizeof(uint8_t),
                   "GuardClassKind must fit in a byte");
     writeOpWithOperandId(CacheOp::GuardClass, obj);
     buffer_.writeByte(uint32_t(kind));
   }
+
   FieldOffset guardAnyClass(ObjOperandId obj, const Class* clasp) {
     writeOpWithOperandId(CacheOp::GuardAnyClass, obj);
     return addStubField(uintptr_t(clasp), StubField::Type::RawWord);
   }
+
   void guardFunctionIsNative(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardFunctionIsNative, obj);
   }
+
   void guardFunctionIsConstructor(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardFunctionIsConstructor, obj);
   }
+
   void guardSpecificNativeFunction(ObjOperandId obj, JSNative nativeFunc) {
     writeOpWithOperandId(CacheOp::GuardSpecificNativeFunction, obj);
     writePointer(JS_FUNC_TO_DATA_PTR(void*, nativeFunc));
   }
+
   void guardIsNativeObject(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardIsNativeObject, obj);
   }
+
   void guardIsProxy(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardIsProxy, obj);
   }
+
   void guardHasProxyHandler(ObjOperandId obj, const void* handler) {
     writeOpWithOperandId(CacheOp::GuardHasProxyHandler, obj);
     addStubField(uintptr_t(handler), StubField::Type::RawWord);
   }
+
   void guardNotDOMProxy(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardNotDOMProxy, obj);
   }
+
   FieldOffset guardSpecificObject(ObjOperandId obj, JSObject* expected) {
     assertSameCompartment(expected);
     writeOpWithOperandId(CacheOp::GuardSpecificObject, obj);
     return addStubField(uintptr_t(expected), StubField::Type::JSObject);
   }
+
   FieldOffset guardSpecificFunction(ObjOperandId obj, JSFunction* expected) {
     // Guard object is a specific function. This implies immutable fields on
     // the JSFunction struct itself are unchanged.
     return guardSpecificObject(obj, expected);
   }
+
   FieldOffset guardSpecificAtom(StringOperandId str, JSAtom* expected) {
     writeOpWithOperandId(CacheOp::GuardSpecificAtom, str);
     return addStubField(uintptr_t(expected), StubField::Type::String);
   }
+
   void guardSpecificSymbol(SymbolOperandId sym, JS::Symbol* expected) {
     writeOpWithOperandId(CacheOp::GuardSpecificSymbol, sym);
     addStubField(uintptr_t(expected), StubField::Type::Symbol);
   }
+
   void guardSpecificInt32Immediate(
       Int32OperandId operand, int32_t expected,
       Assembler::Condition cond = Assembler::Equal) {
     writeOpWithOperandId(CacheOp::GuardSpecificInt32Immediate, operand);
     writeInt32Immediate(expected);
     buffer_.writeByte(uint32_t(cond));
   }
+
   void guardMagicValue(ValOperandId val, JSWhyMagic magic) {
     writeOpWithOperandId(CacheOp::GuardMagicValue, val);
     buffer_.writeByte(uint32_t(magic));
   }
+
   void guardCompartment(ObjOperandId obj, JSObject* global,
                         JS::Compartment* compartment) {
     assertSameCompartment(global);
     writeOpWithOperandId(CacheOp::GuardCompartment, obj);
     // Add a reference to a global in the compartment to keep it alive.
     addStubField(uintptr_t(global), StubField::Type::JSObject);
     // Use RawWord, because compartments never move and it can't be GCed.
     addStubField(uintptr_t(compartment), StubField::Type::RawWord);
   }
+
   void guardIsExtensible(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardIsExtensible, obj);
   }
+
   void guardNoDetachedTypedObjects() {
     writeOp(CacheOp::GuardNoDetachedTypedObjects);
   }
+
   void guardFrameHasNoArgumentsObject() {
     writeOp(CacheOp::GuardFrameHasNoArgumentsObject);
   }
 
   Int32OperandId guardAndGetIndexFromString(StringOperandId str) {
     Int32OperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardAndGetIndexFromString, str);
     writeOperandId(res);
     return res;
   }
+
   ValOperandId guardAndGetNumberFromString(StringOperandId str) {
     ValOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardAndGetNumberFromString, str);
     writeOperandId(res);
     return res;
   }
+
   ObjOperandId guardAndGetIterator(ObjOperandId obj,
                                    PropertyIteratorObject* iter,
                                    NativeIterator** enumeratorsAddr) {
     ObjOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardAndGetIterator, obj);
     addStubField(uintptr_t(iter), StubField::Type::JSObject);
     addStubField(uintptr_t(enumeratorsAddr), StubField::Type::RawWord);
     writeOperandId(res);
     return res;
   }
 
   void guardHasGetterSetter(ObjOperandId obj, Shape* shape) {
     writeOpWithOperandId(CacheOp::GuardHasGetterSetter, obj);
     addStubField(uintptr_t(shape), StubField::Type::Shape);
   }
+
   void guardGroupHasUnanalyzedNewScript(ObjectGroup* group) {
     writeOp(CacheOp::GuardGroupHasUnanalyzedNewScript);
     addStubField(uintptr_t(group), StubField::Type::ObjectGroup);
   }
 
   void guardIndexIsNonNegative(Int32OperandId index) {
     writeOpWithOperandId(CacheOp::GuardIndexIsNonNegative, index);
   }
+
   void guardIndexGreaterThanDenseInitLength(ObjOperandId obj,
                                             Int32OperandId index) {
     writeOpWithOperandId(CacheOp::GuardIndexGreaterThanDenseInitLength, obj);
     writeOperandId(index);
   }
+
   void guardIndexGreaterThanDenseCapacity(ObjOperandId obj,
                                           Int32OperandId index) {
     writeOpWithOperandId(CacheOp::GuardIndexGreaterThanDenseCapacity, obj);
     writeOperandId(index);
   }
+
   void guardIndexGreaterThanArrayLength(ObjOperandId obj,
                                         Int32OperandId index) {
     writeOpWithOperandId(CacheOp::GuardIndexGreaterThanArrayLength, obj);
     writeOperandId(index);
   }
+
   void guardIndexIsValidUpdateOrAdd(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::GuardIndexIsValidUpdateOrAdd, obj);
     writeOperandId(index);
   }
+
   void guardTagNotEqual(ValueTagOperandId lhs, ValueTagOperandId rhs) {
     writeOpWithOperandId(CacheOp::GuardTagNotEqual, lhs);
     writeOperandId(rhs);
   }
 
   void loadFrameCalleeResult() { writeOp(CacheOp::LoadFrameCalleeResult); }
   void loadFrameNumActualArgsResult() {
     writeOp(CacheOp::LoadFrameNumActualArgsResult);
   }
+
   void loadFrameArgumentResult(Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadFrameArgumentResult, index);
   }
+
   void guardNoDenseElements(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::GuardNoDenseElements, obj);
   }
 
   ObjOperandId loadObject(JSObject* obj) {
     assertSameCompartment(obj);
     ObjOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::LoadObject, res);
     addStubField(uintptr_t(obj), StubField::Type::JSObject);
     return res;
   }
+
   ObjOperandId loadProto(ObjOperandId obj) {
     ObjOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::LoadProto, obj);
     writeOperandId(res);
     return res;
   }
 
   ObjOperandId loadEnclosingEnvironment(ObjOperandId obj) {
@@ -1161,67 +1223,74 @@ class MOZ_RAII CacheIRWriter : public JS
   }
 
   ValOperandId loadDOMExpandoValue(ObjOperandId obj) {
     ValOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::LoadDOMExpandoValue, obj);
     writeOperandId(res);
     return res;
   }
+
   void guardDOMExpandoMissingOrGuardShape(ValOperandId expando, Shape* shape) {
     writeOpWithOperandId(CacheOp::GuardDOMExpandoMissingOrGuardShape, expando);
     addStubField(uintptr_t(shape), StubField::Type::Shape);
   }
+
   ValOperandId loadDOMExpandoValueGuardGeneration(
       ObjOperandId obj, ExpandoAndGeneration* expandoAndGeneration) {
     ValOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::LoadDOMExpandoValueGuardGeneration, obj);
     addStubField(uintptr_t(expandoAndGeneration), StubField::Type::RawWord);
     addStubField(expandoAndGeneration->generation,
                  StubField::Type::DOMExpandoGeneration);
     writeOperandId(res);
     return res;
   }
+
   ValOperandId loadDOMExpandoValueIgnoreGeneration(ObjOperandId obj) {
     ValOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::LoadDOMExpandoValueIgnoreGeneration, obj);
     writeOperandId(res);
     return res;
   }
 
   void storeFixedSlot(ObjOperandId obj, size_t offset, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::StoreFixedSlot, obj);
     addStubField(offset, StubField::Type::RawWord);
     writeOperandId(rhs);
   }
+
   void storeDynamicSlot(ObjOperandId obj, size_t offset, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::StoreDynamicSlot, obj);
     addStubField(offset, StubField::Type::RawWord);
     writeOperandId(rhs);
   }
+
   void addAndStoreFixedSlot(ObjOperandId obj, size_t offset, ValOperandId rhs,
                             Shape* newShape, bool changeGroup,
                             ObjectGroup* newGroup) {
     writeOpWithOperandId(CacheOp::AddAndStoreFixedSlot, obj);
     addStubField(offset, StubField::Type::RawWord);
     writeOperandId(rhs);
     buffer_.writeByte(changeGroup);
     addStubField(uintptr_t(newGroup), StubField::Type::ObjectGroup);
     addStubField(uintptr_t(newShape), StubField::Type::Shape);
   }
+
   void addAndStoreDynamicSlot(ObjOperandId obj, size_t offset, ValOperandId rhs,
                               Shape* newShape, bool changeGroup,
                               ObjectGroup* newGroup) {
     writeOpWithOperandId(CacheOp::AddAndStoreDynamicSlot, obj);
     addStubField(offset, StubField::Type::RawWord);
     writeOperandId(rhs);
     buffer_.writeByte(changeGroup);
     addStubField(uintptr_t(newGroup), StubField::Type::ObjectGroup);
     addStubField(uintptr_t(newShape), StubField::Type::Shape);
   }
+
   void allocateAndStoreDynamicSlot(ObjOperandId obj, size_t offset,
                                    ValOperandId rhs, Shape* newShape,
                                    bool changeGroup, ObjectGroup* newGroup,
                                    uint32_t numNewSlots) {
     writeOpWithOperandId(CacheOp::AllocateAndStoreDynamicSlot, obj);
     addStubField(offset, StubField::Type::RawWord);
     writeOperandId(rhs);
     buffer_.writeByte(changeGroup);
@@ -1234,117 +1303,134 @@ class MOZ_RAII CacheIRWriter : public JS
                                          TypedThingLayout layout,
                                          ReferenceType type, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::StoreTypedObjectReferenceProperty, obj);
     addStubField(offset, StubField::Type::RawWord);
     buffer_.writeByte(uint32_t(layout));
     buffer_.writeByte(uint32_t(type));
     writeOperandId(rhs);
   }
+
   void storeTypedObjectScalarProperty(ObjOperandId obj, uint32_t offset,
                                       TypedThingLayout layout,
                                       Scalar::Type type, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::StoreTypedObjectScalarProperty, obj);
     addStubField(offset, StubField::Type::RawWord);
     buffer_.writeByte(uint32_t(layout));
     buffer_.writeByte(uint32_t(type));
     writeOperandId(rhs);
   }
+
   void storeDenseElement(ObjOperandId obj, Int32OperandId index,
                          ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::StoreDenseElement, obj);
     writeOperandId(index);
     writeOperandId(rhs);
   }
+
   void storeTypedElement(ObjOperandId obj, Int32OperandId index,
                          ValOperandId rhs, TypedThingLayout layout,
                          Scalar::Type elementType, bool handleOOB) {
     writeOpWithOperandId(CacheOp::StoreTypedElement, obj);
     writeOperandId(index);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(layout));
     buffer_.writeByte(uint32_t(elementType));
     buffer_.writeByte(uint32_t(handleOOB));
   }
+
   void storeDenseElementHole(ObjOperandId obj, Int32OperandId index,
                              ValOperandId rhs, bool handleAdd) {
     writeOpWithOperandId(CacheOp::StoreDenseElementHole, obj);
     writeOperandId(index);
     writeOperandId(rhs);
     buffer_.writeByte(handleAdd);
   }
+
   void arrayPush(ObjOperandId obj, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::ArrayPush, obj);
     writeOperandId(rhs);
   }
+
   void arrayJoinResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::ArrayJoinResult, obj);
   }
+
   void callScriptedSetter(ObjOperandId obj, JSFunction* setter,
                           ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::CallScriptedSetter, obj);
     addStubField(uintptr_t(setter), StubField::Type::JSObject);
     writeOperandId(rhs);
     buffer_.writeByte(cx_->realm() == setter->realm());
   }
+
   void callNativeSetter(ObjOperandId obj, JSFunction* setter,
                         ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::CallNativeSetter, obj);
     addStubField(uintptr_t(setter), StubField::Type::JSObject);
     writeOperandId(rhs);
   }
+
   void callSetArrayLength(ObjOperandId obj, bool strict, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::CallSetArrayLength, obj);
     buffer_.writeByte(uint32_t(strict));
     writeOperandId(rhs);
   }
+
   void callProxySet(ObjOperandId obj, jsid id, ValOperandId rhs, bool strict) {
     writeOpWithOperandId(CacheOp::CallProxySet, obj);
     writeOperandId(rhs);
     addStubField(uintptr_t(JSID_BITS(id)), StubField::Type::Id);
     buffer_.writeByte(uint32_t(strict));
   }
+
   void callProxySetByValue(ObjOperandId obj, ValOperandId id, ValOperandId rhs,
                            bool strict) {
     writeOpWithOperandId(CacheOp::CallProxySetByValue, obj);
     writeOperandId(id);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(strict));
   }
+
   void callAddOrUpdateSparseElementHelper(ObjOperandId obj, Int32OperandId id,
                                           ValOperandId rhs, bool strict) {
     writeOpWithOperandId(CacheOp::CallAddOrUpdateSparseElementHelper, obj);
     writeOperandId(id);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(strict));
   }
+
   StringOperandId callInt32ToString(Int32OperandId id) {
     StringOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::CallInt32ToString, id);
     writeOperandId(res);
     return res;
   }
+
   StringOperandId callNumberToString(ValOperandId id) {
     StringOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::CallNumberToString, id);
     writeOperandId(res);
     return res;
   }
+
   StringOperandId booleanToString(Int32OperandId id) {
     StringOperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::BooleanToString, id);
     writeOperandId(res);
     return res;
   }
+
   void callScriptedFunction(ObjOperandId calleeId, Int32OperandId argc,
                             CallFlags flags) {
     writeOpWithOperandId(CacheOp::CallScriptedFunction, calleeId);
     writeOperandId(argc);
     writeCallFlags(flags);
   }
+
   void callNativeFunction(ObjOperandId calleeId, Int32OperandId argc, JSOp op,
                           HandleFunction calleeFunc, CallFlags flags) {
     writeOpWithOperandId(CacheOp::CallNativeFunction, calleeId);
     writeOperandId(argc);
     writeCallFlags(flags);
 
     // Some native functions can be implemented faster if we know that
     // the return value is ignored.
@@ -1415,368 +1501,442 @@ class MOZ_RAII CacheIRWriter : public JS
   // field for BaselineInspector.
   void metaNativeTemplateObject(JSObject* templateObject,
                                 FieldOffset calleeOffset) {
     writeOp(CacheOp::MetaTwoByte);
     buffer_.writeByte(uint32_t(MetaTwoByteKind::NativeTemplateObject));
     reuseStubField(calleeOffset);
     addStubField(uintptr_t(templateObject), StubField::Type::JSObject);
   }
+
   void metaScriptedTemplateObject(JSObject* templateObject,
                                   FieldOffset calleeOffset) {
     writeOp(CacheOp::MetaTwoByte);
     buffer_.writeByte(uint32_t(MetaTwoByteKind::ScriptedTemplateObject));
     reuseStubField(calleeOffset);
     addStubField(uintptr_t(templateObject), StubField::Type::JSObject);
   }
+
   void metaClassTemplateObject(JSObject* templateObject,
                                FieldOffset classOffset) {
     writeOp(CacheOp::MetaTwoByte);
     buffer_.writeByte(uint32_t(MetaTwoByteKind::ClassTemplateObject));
     reuseStubField(classOffset);
     addStubField(uintptr_t(templateObject), StubField::Type::JSObject);
   }
+
   void megamorphicLoadSlotResult(ObjOperandId obj, PropertyName* name,
                                  bool handleMissing) {
     writeOpWithOperandId(CacheOp::MegamorphicLoadSlotResult, obj);
     addStubField(uintptr_t(name), StubField::Type::String);
     buffer_.writeByte(uint32_t(handleMissing));
   }
+
   void megamorphicLoadSlotByValueResult(ObjOperandId obj, ValOperandId id,
                                         bool handleMissing) {
     writeOpWithOperandId(CacheOp::MegamorphicLoadSlotByValueResult, obj);
     writeOperandId(id);
     buffer_.writeByte(uint32_t(handleMissing));
   }
+
   void megamorphicStoreSlot(ObjOperandId obj, PropertyName* name,
                             ValOperandId rhs, bool needsTypeBarrier) {
     writeOpWithOperandId(CacheOp::MegamorphicStoreSlot, obj);
     addStubField(uintptr_t(name), StubField::Type::String);
     writeOperandId(rhs);
     buffer_.writeByte(needsTypeBarrier);
   }
+
   void megamorphicSetElement(ObjOperandId obj, ValOperandId id,
                              ValOperandId rhs, bool strict) {
     writeOpWithOperandId(CacheOp::MegamorphicSetElement, obj);
     writeOperandId(id);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(strict));
   }
+
   void megamorphicHasPropResult(ObjOperandId obj, ValOperandId id,
                                 bool hasOwn) {
     writeOpWithOperandId(CacheOp::MegamorphicHasPropResult, obj);
     writeOperandId(id);
     buffer_.writeByte(uint32_t(hasOwn));
   }
 
   void doubleAddResult(ValOperandId lhsId, ValOperandId rhsId) {
     writeOpWithOperandId(CacheOp::DoubleAddResult, lhsId);
     writeOperandId(rhsId);
   }
+
   void doubleSubResult(ValOperandId lhsId, ValOperandId rhsId) {
     writeOpWithOperandId(CacheOp::DoubleSubResult, lhsId);
     writeOperandId(rhsId);
   }
+
   void doubleMulResult(ValOperandId lhsId, ValOperandId rhsId) {
     writeOpWithOperandId(CacheOp::DoubleMulResult, lhsId);
     writeOperandId(rhsId);
   }
+
   void doubleDivResult(ValOperandId lhsId, ValOperandId rhsId) {
     writeOpWithOperandId(CacheOp::DoubleDivResult, lhsId);
     writeOperandId(rhsId);
   }
+
   void doubleModResult(ValOperandId lhsId, ValOperandId rhsId) {
     writeOpWithOperandId(CacheOp::DoubleModResult, lhsId);
     writeOperandId(rhsId);
   }
 
   void int32AddResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32AddResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32SubResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32SubResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32MulResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32MulResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32DivResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32DivResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32ModResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32ModResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32BitOrResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32BitOrResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32BitXOrResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32BitXorResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32BitAndResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32BitAndResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32LeftShiftResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32LeftShiftResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32RightShiftResult(Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::Int32RightShiftResult, lhs);
     writeOperandId(rhs);
   }
+
   void int32URightShiftResult(Int32OperandId lhs, Int32OperandId rhs,
                               bool allowDouble) {
     writeOpWithOperandId(CacheOp::Int32URightShiftResult, lhs);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(allowDouble));
   }
+
   void int32NotResult(Int32OperandId id) {
     writeOpWithOperandId(CacheOp::Int32NotResult, id);
   }
+
   void int32NegationResult(Int32OperandId id) {
     writeOpWithOperandId(CacheOp::Int32NegationResult, id);
   }
+
   void int32IncResult(Int32OperandId id) {
     writeOpWithOperandId(CacheOp::Int32IncResult, id);
   }
+
   void int32DecResult(Int32OperandId id) {
     writeOpWithOperandId(CacheOp::Int32DecResult, id);
   }
+
   void doubleNegationResult(ValOperandId val) {
     writeOpWithOperandId(CacheOp::DoubleNegationResult, val);
   }
+
   void doubleIncResult(ValOperandId val) {
     writeOpWithOperandId(CacheOp::DoubleIncResult, val);
   }
+
   void doubleDecResult(ValOperandId val) {
     writeOpWithOperandId(CacheOp::DoubleDecResult, val);
   }
+
   void loadBooleanResult(bool val) {
     writeOp(CacheOp::LoadBooleanResult);
     buffer_.writeByte(uint32_t(val));
   }
+
   void loadUndefinedResult() { writeOp(CacheOp::LoadUndefinedResult); }
   void loadStringResult(JSString* str) {
     writeOp(CacheOp::LoadStringResult);
     addStubField(uintptr_t(str), StubField::Type::String);
   }
+
   void loadFixedSlotResult(ObjOperandId obj, size_t offset) {
     writeOpWithOperandId(CacheOp::LoadFixedSlotResult, obj);
     addStubField(offset, StubField::Type::RawWord);
   }
+
   void loadDynamicSlotResult(ObjOperandId obj, size_t offset) {
     writeOpWithOperandId(CacheOp::LoadDynamicSlotResult, obj);
     addStubField(offset, StubField::Type::RawWord);
   }
+
   void loadTypedObjectResult(ObjOperandId obj, uint32_t offset,
                              TypedThingLayout layout, uint32_t typeDescr) {
     MOZ_ASSERT(uint32_t(layout) <= UINT8_MAX);
     MOZ_ASSERT(typeDescr <= UINT8_MAX);
     writeOpWithOperandId(CacheOp::LoadTypedObjectResult, obj);
     buffer_.writeByte(uint32_t(layout));
     buffer_.writeByte(typeDescr);
     addStubField(offset, StubField::Type::RawWord);
   }
+
   void loadInt32ArrayLengthResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::LoadInt32ArrayLengthResult, obj);
   }
+
   void loadArgumentsObjectLengthResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::LoadArgumentsObjectLengthResult, obj);
   }
+
   void loadFunctionLengthResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::LoadFunctionLengthResult, obj);
   }
+
   void loadArgumentsObjectArgResult(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadArgumentsObjectArgResult, obj);
     writeOperandId(index);
   }
+
   void loadDenseElementResult(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadDenseElementResult, obj);
     writeOperandId(index);
   }
+
   void loadDenseElementHoleResult(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadDenseElementHoleResult, obj);
     writeOperandId(index);
   }
+
   void callGetSparseElementResult(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::CallGetSparseElementResult, obj);
     writeOperandId(index);
   }
+
   void loadDenseElementExistsResult(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadDenseElementExistsResult, obj);
     writeOperandId(index);
   }
+
   void loadTypedElementExistsResult(ObjOperandId obj, Int32OperandId index,
                                     TypedThingLayout layout) {
     writeOpWithOperandId(CacheOp::LoadTypedElementExistsResult, obj);
     writeOperandId(index);
     buffer_.writeByte(uint32_t(layout));
   }
+
   void loadDenseElementHoleExistsResult(ObjOperandId obj,
                                         Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadDenseElementHoleExistsResult, obj);
     writeOperandId(index);
   }
+
   void loadTypedElementResult(ObjOperandId obj, Int32OperandId index,
                               TypedThingLayout layout,
                               Scalar::Type elementType) {
     writeOpWithOperandId(CacheOp::LoadTypedElementResult, obj);
     writeOperandId(index);
     buffer_.writeByte(uint32_t(layout));
     buffer_.writeByte(uint32_t(elementType));
   }
+
   void loadStringLengthResult(StringOperandId str) {
     writeOpWithOperandId(CacheOp::LoadStringLengthResult, str);
   }
+
   void loadStringCharResult(StringOperandId str, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::LoadStringCharResult, str);
     writeOperandId(index);
   }
+
   void callScriptedGetterResult(ObjOperandId obj, JSFunction* getter) {
     writeOpWithOperandId(CacheOp::CallScriptedGetterResult, obj);
     addStubField(uintptr_t(getter), StubField::Type::JSObject);
     buffer_.writeByte(cx_->realm() == getter->realm());
   }
+
   void callScriptedGetterByValueResult(ValOperandId obj, JSFunction* getter) {
     writeOpWithOperandId(CacheOp::CallScriptedGetterByValueResult, obj);
     addStubField(uintptr_t(getter), StubField::Type::JSObject);
     buffer_.writeByte(cx_->realm() == getter->realm());
   }
+
   void callNativeGetterResult(ObjOperandId obj, JSFunction* getter) {
     writeOpWithOperandId(CacheOp::CallNativeGetterResult, obj);
     addStubField(uintptr_t(getter), StubField::Type::JSObject);
   }
+
   void callNativeGetterByValueResult(ValOperandId obj, JSFunction* getter) {
     writeOpWithOperandId(CacheOp::CallNativeGetterByValueResult, obj);
     addStubField(uintptr_t(getter), StubField::Type::JSObject);
   }
+
   void callProxyGetResult(ObjOperandId obj, jsid id) {
     writeOpWithOperandId(CacheOp::CallProxyGetResult, obj);
     addStubField(uintptr_t(JSID_BITS(id)), StubField::Type::Id);
   }
+
   void callProxyGetByValueResult(ObjOperandId obj, ValOperandId idVal) {
     writeOpWithOperandId(CacheOp::CallProxyGetByValueResult, obj);
     writeOperandId(idVal);
   }
+
   void callProxyHasPropResult(ObjOperandId obj, ValOperandId idVal,
                               bool hasOwn) {
     writeOpWithOperandId(CacheOp::CallProxyHasPropResult, obj);
     writeOperandId(idVal);
     buffer_.writeByte(uint32_t(hasOwn));
   }
+
   void callObjectHasSparseElementResult(ObjOperandId obj,
                                         Int32OperandId index) {
     writeOpWithOperandId(CacheOp::CallObjectHasSparseElementResult, obj);
     writeOperandId(index);
   }
+
   void callNativeGetElementResult(ObjOperandId obj, Int32OperandId index) {
     writeOpWithOperandId(CacheOp::CallNativeGetElementResult, obj);
     writeOperandId(index);
   }
+
   void callIsSuspendedGeneratorResult(ValOperandId val) {
     writeOpWithOperandId(CacheOp::CallIsSuspendedGeneratorResult, val);
   }
+
   void loadEnvironmentFixedSlotResult(ObjOperandId obj, size_t offset) {
     writeOpWithOperandId(CacheOp::LoadEnvironmentFixedSlotResult, obj);
     addStubField(offset, StubField::Type::RawWord);
   }
+
   void loadEnvironmentDynamicSlotResult(ObjOperandId obj, size_t offset) {
     writeOpWithOperandId(CacheOp::LoadEnvironmentDynamicSlotResult, obj);
     addStubField(offset, StubField::Type::RawWord);
   }
+
   void loadObjectResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::LoadObjectResult, obj);
   }
+
   void loadInstanceOfObjectResult(ValOperandId lhs, ObjOperandId protoId,
                                   uint32_t slot) {
     writeOpWithOperandId(CacheOp::LoadInstanceOfObjectResult, lhs);
     writeOperandId(protoId);
   }
+
   void loadTypeOfObjectResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::LoadTypeOfObjectResult, obj);
   }
+
   void loadInt32TruthyResult(ValOperandId integer) {
     writeOpWithOperandId(CacheOp::LoadInt32TruthyResult, integer);
   }
+
   void loadDoubleTruthyResult(ValOperandId dbl) {
     writeOpWithOperandId(CacheOp::LoadDoubleTruthyResult, dbl);
   }
+
   void loadStringTruthyResult(StringOperandId str) {
     writeOpWithOperandId(CacheOp::LoadStringTruthyResult, str);
   }
+
   void loadObjectTruthyResult(ObjOperandId obj) {
     writeOpWithOperandId(CacheOp::LoadObjectTruthyResult, obj);
   }
+
   void loadValueResult(const Value& val) {
     writeOp(CacheOp::LoadValueResult);
     addStubField(val.asRawBits(), StubField::Type::Value);
   }
+
   void loadNewObjectFromTemplateResult(JSObject* templateObj) {
     writeOp(CacheOp::LoadNewObjectFromTemplateResult);
     addStubField(uintptr_t(templateObj), StubField::Type::JSObject);
     // Bake in a monotonically increasing number to ensure we differentiate
     // between different baseline stubs that otherwise might share
     // stub code.
     uint64_t id = cx_->runtime()->jitRuntime()->nextDisambiguationId();
     writeUint32Immediate(id & UINT32_MAX);
     writeUint32Immediate(id >> 32);
   }
+
   void callStringConcatResult(StringOperandId lhs, StringOperandId rhs) {
     writeOpWithOperandId(CacheOp::CallStringConcatResult, lhs);
     writeOperandId(rhs);
   }
+
   void callStringObjectConcatResult(ValOperandId lhs, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::CallStringObjectConcatResult, lhs);
     writeOperandId(rhs);
   }
 
   void compareStringResult(uint32_t op, StringOperandId lhs,
                            StringOperandId rhs) {
     writeOpWithOperandId(CacheOp::CompareStringResult, lhs);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(op));
   }
+
   void compareObjectResult(uint32_t op, ObjOperandId lhs, ObjOperandId rhs) {
     writeOpWithOperandId(CacheOp::CompareObjectResult, lhs);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(op));
   }
+
   void compareObjectUndefinedNullResult(uint32_t op, ObjOperandId object) {
     writeOpWithOperandId(CacheOp::CompareObjectUndefinedNullResult, object);
     buffer_.writeByte(uint32_t(op));
   }
+
   void compareSymbolResult(uint32_t op, SymbolOperandId lhs,
                            SymbolOperandId rhs) {
     writeOpWithOperandId(CacheOp::CompareSymbolResult, lhs);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(op));
   }
+
   void compareInt32Result(uint32_t op, Int32OperandId lhs, Int32OperandId rhs) {
     writeOpWithOperandId(CacheOp::CompareInt32Result, lhs);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(op));
   }
+
   void compareDoubleResult(uint32_t op, ValOperandId lhs, ValOperandId rhs) {
     writeOpWithOperandId(CacheOp::CompareDoubleResult, lhs);
     writeOperandId(rhs);
     buffer_.writeByte(uint32_t(op));
   }
 
   void callPrintString(const char* str) {
     writeOp(CacheOp::CallPrintString);
     writePointer(const_cast<char*>(str));
   }
+
   void breakpoint() { writeOp(CacheOp::Breakpoint); }
-
   void typeMonitorResult() { writeOp(CacheOp::TypeMonitorResult); }
   void returnFromIC() { writeOp(CacheOp::ReturnFromIC); }
   void wrapResult() { writeOp(CacheOp::WrapResult); }
 };
 
 class CacheIRStubInfo;
 
 // Helper class for reading CacheIR bytecode.
@@ -1804,48 +1964,54 @@ class MOZ_RAII CacheIRReader {
       buffer_.seek(buffer_.currentPosition(), skipLength);
     }
   }
 
   ValOperandId valOperandId() { return ValOperandId(buffer_.readByte()); }
   ValueTagOperandId valueTagOperandId() {
     return ValueTagOperandId(buffer_.readByte());
   }
+
   ObjOperandId objOperandId() { return ObjOperandId(buffer_.readByte()); }
   StringOperandId stringOperandId() {
     return StringOperandId(buffer_.readByte());
   }
+
   SymbolOperandId symbolOperandId() {
     return SymbolOperandId(buffer_.readByte());
   }
+
   Int32OperandId int32OperandId() { return Int32OperandId(buffer_.readByte()); }
 
   uint32_t stubOffset() { return buffer_.readByte() * sizeof(uintptr_t); }
   GuardClassKind guardClassKind() { return GuardClassKind(buffer_.readByte()); }
   JSValueType jsValueType() { return JSValueType(buffer_.readByte()); }
   ValueType valueType() { return ValueType(buffer_.readByte()); }
+
   TypedThingLayout typedThingLayout() {
     return TypedThingLayout(buffer_.readByte());
   }
+
   Scalar::Type scalarType() { return Scalar::Type(buffer_.readByte()); }
   uint32_t typeDescrKey() { return buffer_.readByte(); }
   JSWhyMagic whyMagic() { return JSWhyMagic(buffer_.readByte()); }
   JSOp jsop() { return JSOp(buffer_.readByte()); }
   int32_t int32Immediate() { return int32_t(buffer_.readFixedUint32_t()); }
   uint32_t uint32Immediate() { return buffer_.readFixedUint32_t(); }
   void* pointer() { return buffer_.readRawPointer(); }
 
   template <typename MetaKind>
   MetaKind metaKind() {
     return MetaKind(buffer_.readByte());
   }
 
   ReferenceType referenceTypeDescrType() {
     return ReferenceType(buffer_.readByte());
   }
+
   CallFlags callFlags() {
     // See CacheIRWriter::writeCallFlags()
     uint8_t encoded = buffer_.readByte();
     CallFlags::ArgFormat format =
         CallFlags::ArgFormat(encoded & CallFlags::ArgFormatMask);
     bool isConstructing = encoded & CallFlags::IsConstructing;
     bool isSameRealm = encoded & CallFlags::IsSameRealm;
     switch (format) {
@@ -1871,24 +2037,26 @@ class MOZ_RAII CacheIRReader {
   bool matchOp(CacheOp op) {
     const uint8_t* pos = buffer_.currentPosition();
     if (readOp() == op) {
       return true;
     }
     buffer_.seek(pos, 0);
     return false;
   }
+
   bool matchOp(CacheOp op, OperandId id) {
     const uint8_t* pos = buffer_.currentPosition();
     if (readOp() == op && buffer_.readByte() == id.id()) {
       return true;
     }
     buffer_.seek(pos, 0);
     return false;
   }
+
   bool matchOpEither(CacheOp op1, CacheOp op2) {
     const uint8_t* pos = buffer_.currentPosition();
     CacheOp op = readOp();
     if (op == op1 || op == op2) {
       return true;
     }
     buffer_.seek(pos, 0);
     return false;
@@ -2075,16 +2243,17 @@ class MOZ_RAII GetPropIRGenerator : publ
                      GetPropertyResultFlags resultFlags);
 
   AttachDecision tryAttachStub();
   AttachDecision tryAttachIdempotentStub();
 
   bool shouldUnlinkPreliminaryObjectStubs() const {
     return preliminaryObjectAction_ == PreliminaryObjectAction::Unlink;
   }
+
   bool shouldNotePreliminaryObjectStub() const {
     return preliminaryObjectAction_ == PreliminaryObjectAction::NotePreliminary;
   }
 };
 
 // GetNameIRGenerator generates CacheIR for a GetName IC.
 class MOZ_RAII GetNameIRGenerator : public IRGenerator {
   HandleObject env_;
@@ -2132,20 +2301,22 @@ class MOZ_RAII PropertyTypeCheckInfo {
   void operator=(const PropertyTypeCheckInfo&) = delete;
 
  public:
   PropertyTypeCheckInfo(JSContext* cx, bool needsTypeBarrier)
       : group_(cx), id_(cx), needsTypeBarrier_(needsTypeBarrier) {}
 
   bool needsTypeBarrier() const { return needsTypeBarrier_; }
   bool isSet() const { return group_ != nullptr; }
+
   ObjectGroup* group() const {
     MOZ_ASSERT(isSet());
     return group_;
   }
+
   jsid id() const {
     MOZ_ASSERT(isSet());
     return id_;
   }
 
   void set(ObjectGroup* group, jsid id) {
     MOZ_ASSERT(!group_);
     MOZ_ASSERT(group);
@@ -2174,16 +2345,17 @@ class MOZ_RAII SetPropIRGenerator : publ
 
  private:
   DeferType deferType_ = DeferType::None;
 
   ValOperandId setElemKeyValueId() const {
     MOZ_ASSERT(cacheKind_ == CacheKind::SetElem);
     return ValOperandId(1);
   }
+
   ValOperandId rhsValueId() const {
     if (cacheKind_ == CacheKind::SetProp) {
       return ValOperandId(1);
     }
     MOZ_ASSERT(cacheKind_ == CacheKind::SetElem);
     return ValOperandId(2);
   }
 
@@ -2259,16 +2431,17 @@ class MOZ_RAII SetPropIRGenerator : publ
   AttachDecision tryAttachStub();
   AttachDecision tryAttachAddSlotStub(HandleObjectGroup oldGroup,
                                       HandleShape oldShape);
   void trackAttached(const char* name);
 
   bool shouldUnlinkPreliminaryObjectStubs() const {
     return preliminaryObjectAction_ == PreliminaryObjectAction::Unlink;
   }
+
   bool shouldNotePreliminaryObjectStub() const {
     return preliminaryObjectAction_ == PreliminaryObjectAction::NotePreliminary;
   }
 
   const PropertyTypeCheckInfo* typeCheckInfo() const { return &typeCheckInfo_; }
 
   bool attachedTypedArrayOOBStub() const { return attachedTypedArrayOOBStub_; }