Backed out 3 changesets (bug 1642593) for sm bustages on InlinableNatives.h. CLOSED TREE
authorBrindusan Cristian <cbrindusan@mozilla.com>
Wed, 03 Jun 2020 02:41:51 +0300
changeset 597708 b3f2a9279984e2376a37d4737a21ea662a859d26
parent 597707 7d92961ab6c496aaf6458cb824ff228e81e91c95
child 597709 412ba3cc742c0ab84297ad9ca22c3dc8051f62e3
push id13310
push userffxbld-merge
push dateMon, 29 Jun 2020 14:50:06 +0000
treeherdermozilla-beta@15a59a0afa5c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1642593
milestone79.0a1
backs out4fc6b0a08a293697b99834cd4f19fa10c96f34a7
6f7ef41e1713f27f0648a2dbe0166a334b8d1803
249b7000aaf87ab223e56f01cc8b6fc06ea5c538
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
Backed out 3 changesets (bug 1642593) for sm bustages on InlinableNatives.h. CLOSED TREE Backed out changeset 4fc6b0a08a29 (bug 1642593) Backed out changeset 6f7ef41e1713 (bug 1642593) Backed out changeset 249b7000aaf8 (bug 1642593)
js/src/jit/CacheIR.cpp
js/src/jit/CacheIR.h
js/src/jit/CacheIROps.yaml
js/src/jit/InlinableNatives.cpp
js/src/jit/InlinableNatives.h
js/src/jit/IonBuilder.h
js/src/jit/MCallOptimize.cpp
js/src/jit/WarpCacheIRTranspiler.cpp
js/src/jit/moz.build
--- a/js/src/jit/CacheIR.cpp
+++ b/js/src/jit/CacheIR.cpp
@@ -5172,53 +5172,16 @@ AttachDecision CallIRGenerator::tryAttac
   // returns a boolean.
   writer.returnFromIC();
   cacheIRStubKind_ = BaselineCacheIRStubKind::Regular;
 
   trackAttached("IsConstructor");
   return AttachDecision::Attach;
 }
 
-AttachDecision CallIRGenerator::tryAttachGuardToClass(HandleFunction callee,
-                                                      InlinableNative native) {
-  // Need a single object argument.
-  if (argc_ != 1 || !args_[0].isObject()) {
-    return AttachDecision::NoAction;
-  }
-
-  // Class must match.
-  const JSClass* clasp = InlinableNativeGuardToClass(native);
-  if (args_[0].toObject().getClass() != clasp) {
-    return AttachDecision::NoAction;
-  }
-
-  // Initialize the input operand.
-  Int32OperandId argcId(writer.setInputOperandId(0));
-
-  // Guard callee is the 'GuardToXXX' native function.
-  emitNativeCalleeGuard(callee);
-
-  // Guard that the argument is an object.
-  ValOperandId argId = writer.loadArgumentFixedSlot(ArgumentKind::Arg0, argc_);
-  ObjOperandId objId = writer.guardToObject(argId);
-
-  // Guard that the object has the correct class.
-  writer.guardAnyClass(objId, clasp);
-
-  // Return the object.
-  writer.loadObjectResult(objId);
-
-  // Monitor the returned object.
-  writer.typeMonitorResult();
-  cacheIRStubKind_ = BaselineCacheIRStubKind::Monitored;
-
-  trackAttached("GuardToClass");
-  return AttachDecision::Attach;
-}
-
 AttachDecision CallIRGenerator::tryAttachStringChar(HandleFunction callee,
                                                     StringChar kind) {
   // Need one argument.
   if (argc_ != 1) {
     return AttachDecision::NoAction;
   }
 
   if (!CanAttachStringChar(thisval_, args_[0], kind)) {
@@ -5627,56 +5590,40 @@ AttachDecision CallIRGenerator::tryAttac
   }
 
   if (!callee->hasJitInfo() ||
       callee->jitInfo()->type() != JSJitInfo::InlinableNative) {
     return AttachDecision::NoAction;
   }
 
   // Check for special-cased native functions.
-  switch (InlinableNative native = callee->jitInfo()->inlinableNative) {
+  switch (callee->jitInfo()->inlinableNative) {
     // Array natives.
     case InlinableNative::ArrayPush:
       return tryAttachArrayPush(callee);
     case InlinableNative::ArrayJoin:
       return tryAttachArrayJoin(callee);
     case InlinableNative::ArrayIsArray:
       return tryAttachArrayIsArray(callee);
 
-    // Intl natives.
-    case InlinableNative::IntlGuardToCollator:
-    case InlinableNative::IntlGuardToDateTimeFormat:
-    case InlinableNative::IntlGuardToDisplayNames:
-    case InlinableNative::IntlGuardToListFormat:
-    case InlinableNative::IntlGuardToNumberFormat:
-    case InlinableNative::IntlGuardToPluralRules:
-    case InlinableNative::IntlGuardToRelativeTimeFormat:
-      return tryAttachGuardToClass(callee, native);
-
     // Intrinsics.
     case InlinableNative::IntrinsicIsSuspendedGenerator:
       return tryAttachIsSuspendedGenerator(callee);
     case InlinableNative::IntrinsicToString:
       return tryAttachToString(callee);
     case InlinableNative::IntrinsicToObject:
       return tryAttachToObject(callee);
     case InlinableNative::IntrinsicToInteger:
       return tryAttachToInteger(callee);
     case InlinableNative::IntrinsicIsObject:
       return tryAttachIsObject(callee);
     case InlinableNative::IntrinsicIsCallable:
       return tryAttachIsCallable(callee);
     case InlinableNative::IntrinsicIsConstructor:
       return tryAttachIsConstructor(callee);
-    case InlinableNative::IntrinsicGuardToArrayIterator:
-    case InlinableNative::IntrinsicGuardToMapIterator:
-    case InlinableNative::IntrinsicGuardToSetIterator:
-    case InlinableNative::IntrinsicGuardToStringIterator:
-    case InlinableNative::IntrinsicGuardToRegExpStringIterator:
-      return tryAttachGuardToClass(callee, native);
 
     // String natives.
     case InlinableNative::StringCharCodeAt:
       return tryAttachStringCharCodeAt(callee);
     case InlinableNative::StringCharAt:
       return tryAttachStringCharAt(callee);
 
     // Math natives.
@@ -5724,32 +5671,16 @@ AttachDecision CallIRGenerator::tryAttac
       return tryAttachMathFunction(callee, UnaryMathFunction::ACosH);
     case InlinableNative::MathASinH:
       return tryAttachMathFunction(callee, UnaryMathFunction::ASinH);
     case InlinableNative::MathATanH:
       return tryAttachMathFunction(callee, UnaryMathFunction::ATanH);
     case InlinableNative::MathCbrt:
       return tryAttachMathFunction(callee, UnaryMathFunction::Cbrt);
 
-    // Map intrinsics.
-    case InlinableNative::IntrinsicGuardToMapObject:
-      return tryAttachGuardToClass(callee, native);
-
-    // Set intrinsics.
-    case InlinableNative::IntrinsicGuardToSetObject:
-      return tryAttachGuardToClass(callee, native);
-
-    // ArrayBuffer intrinsics.
-    case InlinableNative::IntrinsicGuardToArrayBuffer:
-      return tryAttachGuardToClass(callee, native);
-
-    // SharedArrayBuffer intrinsics.
-    case InlinableNative::IntrinsicGuardToSharedArrayBuffer:
-      return tryAttachGuardToClass(callee, native);
-
     default:
       return AttachDecision::NoAction;
   }
 }
 
 // Remember the template object associated with any script being called
 // as a constructor, for later use during Ion compilation.
 bool CallIRGenerator::getTemplateObjectForScripted(HandleFunction calleeFunc,
--- a/js/src/jit/CacheIR.h
+++ b/js/src/jit/CacheIR.h
@@ -21,17 +21,16 @@
 #include "jit/Simulator.h"
 #include "vm/Iteration.h"
 #include "vm/Shape.h"
 
 namespace js {
 namespace jit {
 
 enum class BaselineCacheIRStubKind;
-enum class InlinableNative : uint16_t;
 
 // [SMDOC] CacheIR
 //
 // CacheIR is an (extremely simple) linear IR language for inline caches.
 // From this IR, we can generate machine code for Baseline or Ion IC stubs.
 //
 // IRWriter
 // --------
@@ -1524,18 +1523,16 @@ class MOZ_RAII CallIRGenerator : public 
   AttachDecision tryAttachArrayIsArray(HandleFunction callee);
   AttachDecision tryAttachIsSuspendedGenerator(HandleFunction callee);
   AttachDecision tryAttachToString(HandleFunction callee);
   AttachDecision tryAttachToObject(HandleFunction callee);
   AttachDecision tryAttachToInteger(HandleFunction callee);
   AttachDecision tryAttachIsObject(HandleFunction callee);
   AttachDecision tryAttachIsCallable(HandleFunction callee);
   AttachDecision tryAttachIsConstructor(HandleFunction callee);
-  AttachDecision tryAttachGuardToClass(HandleFunction callee,
-                                       InlinableNative native);
   AttachDecision tryAttachStringChar(HandleFunction callee, StringChar kind);
   AttachDecision tryAttachStringCharCodeAt(HandleFunction callee);
   AttachDecision tryAttachStringCharAt(HandleFunction callee);
   AttachDecision tryAttachMathAbs(HandleFunction callee);
   AttachDecision tryAttachMathFloor(HandleFunction callee);
   AttachDecision tryAttachMathCeil(HandleFunction callee);
   AttachDecision tryAttachMathRound(HandleFunction callee);
   AttachDecision tryAttachMathSqrt(HandleFunction callee);
--- a/js/src/jit/CacheIROps.yaml
+++ b/js/src/jit/CacheIROps.yaml
@@ -186,17 +186,17 @@
   transpile: true
   args:
     obj: ObjId
     kind: GuardClassKindImm
 
 # Guard on an arbitrary JSClass.
 - name: GuardAnyClass
   shared: false
-  transpile: true
+  transpile: false
   args:
     obj: ObjId
     clasp: RawPointerField
 
 # Add a reference to a global in the compartment to keep it alive.
 - name: GuardCompartment
   shared: false
   transpile: false
deleted file mode 100644
--- a/js/src/jit/InlinableNatives.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- * vim: set ts=8 sts=2 et sw=2 tw=80:
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "jit/InlinableNatives.h"
-
-#ifdef JS_HAS_INTL_API
-#  include "builtin/intl/Collator.h"
-#  include "builtin/intl/DateTimeFormat.h"
-#  include "builtin/intl/DisplayNames.h"
-#  include "builtin/intl/ListFormat.h"
-#  include "builtin/intl/NumberFormat.h"
-#  include "builtin/intl/PluralRules.h"
-#  include "builtin/intl/RelativeTimeFormat.h"
-#endif
-#include "builtin/MapObject.h"
-#include "vm/ArrayBufferObject.h"
-#include "vm/Iteration.h"
-#include "vm/SharedArrayObject.h"
-
-const JSClass* js::jit::InlinableNativeGuardToClass(InlinableNative native) {
-  switch (native) {
-#ifdef JS_HAS_INTL_API
-    // Intl natives.
-    case InlinableNative::IntlGuardToCollator:
-      return &CollatorObject::class_;
-    case InlinableNative::IntlGuardToDateTimeFormat:
-      return &DateTimeFormatObject::class_;
-    case InlinableNative::IntlGuardToDisplayNames:
-      return &DisplayNamesObject::class_;
-    case InlinableNative::IntlGuardToListFormat:
-      return &ListFormatObject::class_;
-    case InlinableNative::IntlGuardToNumberFormat:
-      return &NumberFormatObject::class_;
-    case InlinableNative::IntlGuardToPluralRules:
-      return &PluralRulesObject::class_;
-    case InlinableNative::IntlGuardToRelativeTimeFormat:
-      return &RelativeTimeFormatObject::class_;
-#else
-    case InlinableNative::IntlGuardToCollator:
-    case InlinableNative::IntlGuardToDateTimeFormat:
-    case InlinableNative::IntlGuardToDisplayNames:
-    case InlinableNative::IntlGuardToListFormat:
-    case InlinableNative::IntlGuardToNumberFormat:
-    case InlinableNative::IntlGuardToPluralRules:
-    case InlinableNative::IntlGuardToRelativeTimeFormat:
-      MOZ_CRASH("Intl API disabled");
-#endif
-
-    // Utility intrinsics.
-    case InlinableNative::IntrinsicGuardToArrayIterator:
-      return &ArrayIteratorObject::class_;
-    case InlinableNative::IntrinsicGuardToMapIterator:
-      return &MapIteratorObject::class_;
-    case InlinableNative::IntrinsicGuardToSetIterator:
-      return &SetIteratorObject::class_;
-    case InlinableNative::IntrinsicGuardToStringIterator:
-      return &StringIteratorObject::class_;
-    case InlinableNative::IntrinsicGuardToRegExpStringIterator:
-      return &RegExpStringIteratorObject::class_;
-
-    case InlinableNative::IntrinsicGuardToMapObject:
-      return &MapObject::class_;
-    case InlinableNative::IntrinsicGuardToSetObject:
-      return &SetObject::class_;
-    case InlinableNative::IntrinsicGuardToArrayBuffer:
-      return &ArrayBufferObject::class_;
-    case InlinableNative::IntrinsicGuardToSharedArrayBuffer:
-      return &SharedArrayBufferObject::class_;
-
-    default:
-      MOZ_CRASH("Not a GuardTo instruction");
-  }
-}
\ No newline at end of file
--- a/js/src/jit/InlinableNatives.h
+++ b/js/src/jit/InlinableNatives.h
@@ -190,14 +190,12 @@ enum class InlinableNative : uint16_t {
 #undef ADD_NATIVE
       Limit
 };
 
 #define ADD_NATIVE(native) extern const JSJitInfo JitInfo_##native;
 INLINABLE_NATIVE_LIST(ADD_NATIVE)
 #undef ADD_NATIVE
 
-const JSClass* InlinableNativeGuardToClass(InlinableNative native);
-
 }  // namespace jit
 }  // namespace js
 
 #endif /* jit_InlinableNatives_h */
--- a/js/src/jit/IonBuilder.h
+++ b/js/src/jit/IonBuilder.h
@@ -837,17 +837,17 @@ class MOZ_STACK_CLASS IonBuilder {
   InliningResult inlineIsCrossRealmArrayConstructor(CallInfo& callInfo);
   InliningResult inlineToInteger(CallInfo& callInfo);
   InliningResult inlineToString(CallInfo& callInfo);
   InliningResult inlineDump(CallInfo& callInfo);
   InliningResult inlineHasClass(CallInfo& callInfo, const JSClass* clasp,
                                 const JSClass* clasp2 = nullptr,
                                 const JSClass* clasp3 = nullptr,
                                 const JSClass* clasp4 = nullptr);
-  InliningResult inlineGuardToClass(CallInfo& callInfo, InlinableNative native);
+  InliningResult inlineGuardToClass(CallInfo& callInfo, const JSClass* clasp);
   InliningResult inlineIsConstructing(CallInfo& callInfo);
   InliningResult inlineSubstringKernel(CallInfo& callInfo);
   InliningResult inlineObjectHasPrototype(CallInfo& callInfo);
   InliningResult inlineFinishBoundFunctionInit(CallInfo& callInfo);
   InliningResult inlineIsPackedArray(CallInfo& callInfo);
   InliningResult inlineWasmCall(CallInfo& callInfo, JSFunction* target);
 
   // Testing functions.
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -5,16 +5,25 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/Casting.h"
 
 #include "jsmath.h"
 
 #include "builtin/AtomicsObject.h"
 #include "builtin/DataViewObject.h"
+#ifdef JS_HAS_INTL_API
+#  include "builtin/intl/Collator.h"
+#  include "builtin/intl/DateTimeFormat.h"
+#  include "builtin/intl/DisplayNames.h"
+#  include "builtin/intl/ListFormat.h"
+#  include "builtin/intl/NumberFormat.h"
+#  include "builtin/intl/PluralRules.h"
+#  include "builtin/intl/RelativeTimeFormat.h"
+#endif
 #include "builtin/MapObject.h"
 #include "builtin/String.h"
 #include "builtin/TestingFunctions.h"
 #include "builtin/TypedObject.h"
 #include "jit/BaselineInspector.h"
 #include "jit/InlinableNatives.h"
 #include "jit/IonBuilder.h"
 #include "jit/Lowering.h"
@@ -355,23 +364,29 @@ IonBuilder::InliningResult IonBuilder::i
     case InlinableNative::DataViewSetBigInt64:
       return inlineDataViewSet(callInfo, Scalar::BigInt64);
     case InlinableNative::DataViewSetBigUint64:
       return inlineDataViewSet(callInfo, Scalar::BigUint64);
 
 #ifdef JS_HAS_INTL_API
     // Intl natives.
     case InlinableNative::IntlGuardToCollator:
+      return inlineGuardToClass(callInfo, &CollatorObject::class_);
     case InlinableNative::IntlGuardToDateTimeFormat:
+      return inlineGuardToClass(callInfo, &DateTimeFormatObject::class_);
     case InlinableNative::IntlGuardToDisplayNames:
+      return inlineGuardToClass(callInfo, &DisplayNamesObject::class_);
     case InlinableNative::IntlGuardToListFormat:
+      return inlineGuardToClass(callInfo, &ListFormatObject::class_);
     case InlinableNative::IntlGuardToNumberFormat:
+      return inlineGuardToClass(callInfo, &NumberFormatObject::class_);
     case InlinableNative::IntlGuardToPluralRules:
+      return inlineGuardToClass(callInfo, &PluralRulesObject::class_);
     case InlinableNative::IntlGuardToRelativeTimeFormat:
-      return inlineGuardToClass(callInfo, inlNative);
+      return inlineGuardToClass(callInfo, &RelativeTimeFormatObject::class_);
 #else
     case InlinableNative::IntlGuardToCollator:
     case InlinableNative::IntlGuardToDateTimeFormat:
     case InlinableNative::IntlGuardToDisplayNames:
     case InlinableNative::IntlGuardToListFormat:
     case InlinableNative::IntlGuardToNumberFormat:
     case InlinableNative::IntlGuardToPluralRules:
     case InlinableNative::IntlGuardToRelativeTimeFormat:
@@ -545,53 +560,57 @@ IonBuilder::InliningResult IonBuilder::i
       return inlineToInteger(callInfo);
     case InlinableNative::IntrinsicToString:
       return inlineToString(callInfo);
     case InlinableNative::IntrinsicIsConstructing:
       return inlineIsConstructing(callInfo);
     case InlinableNative::IntrinsicSubstringKernel:
       return inlineSubstringKernel(callInfo);
     case InlinableNative::IntrinsicGuardToArrayIterator:
+      return inlineGuardToClass(callInfo, &ArrayIteratorObject::class_);
     case InlinableNative::IntrinsicGuardToMapIterator:
+      return inlineGuardToClass(callInfo, &MapIteratorObject::class_);
     case InlinableNative::IntrinsicGuardToSetIterator:
+      return inlineGuardToClass(callInfo, &SetIteratorObject::class_);
     case InlinableNative::IntrinsicGuardToStringIterator:
+      return inlineGuardToClass(callInfo, &StringIteratorObject::class_);
     case InlinableNative::IntrinsicGuardToRegExpStringIterator:
-      return inlineGuardToClass(callInfo, inlNative);
+      return inlineGuardToClass(callInfo, &RegExpStringIteratorObject::class_);
     case InlinableNative::IntrinsicObjectHasPrototype:
       return inlineObjectHasPrototype(callInfo);
     case InlinableNative::IntrinsicFinishBoundFunctionInit:
       return inlineFinishBoundFunctionInit(callInfo);
     case InlinableNative::IntrinsicIsPackedArray:
       return inlineIsPackedArray(callInfo);
 
     // Map intrinsics.
     case InlinableNative::IntrinsicGuardToMapObject:
-      return inlineGuardToClass(callInfo, inlNative);
+      return inlineGuardToClass(callInfo, &MapObject::class_);
     case InlinableNative::IntrinsicGetNextMapEntryForIterator:
       return inlineGetNextEntryForIterator(callInfo,
                                            MGetNextEntryForIterator::Map);
 
     // Set intrinsics.
     case InlinableNative::IntrinsicGuardToSetObject:
-      return inlineGuardToClass(callInfo, inlNative);
+      return inlineGuardToClass(callInfo, &SetObject::class_);
     case InlinableNative::IntrinsicGetNextSetEntryForIterator:
       return inlineGetNextEntryForIterator(callInfo,
                                            MGetNextEntryForIterator::Set);
 
     // ArrayBuffer intrinsics.
     case InlinableNative::IntrinsicGuardToArrayBuffer:
-      return inlineGuardToClass(callInfo, inlNative);
+      return inlineGuardToClass(callInfo, &ArrayBufferObject::class_);
     case InlinableNative::IntrinsicArrayBufferByteLength:
       return inlineArrayBufferByteLength(callInfo);
     case InlinableNative::IntrinsicPossiblyWrappedArrayBufferByteLength:
       return inlinePossiblyWrappedArrayBufferByteLength(callInfo);
 
     // SharedArrayBuffer intrinsics.
     case InlinableNative::IntrinsicGuardToSharedArrayBuffer:
-      return inlineGuardToClass(callInfo, inlNative);
+      return inlineGuardToClass(callInfo, &SharedArrayBufferObject::class_);
 
     // TypedArray intrinsics.
     case InlinableNative::TypedArrayConstructor:
       return inlineTypedArray(callInfo, target->native());
     case InlinableNative::IntrinsicIsTypedArrayConstructor:
       return inlineIsTypedArrayConstructor(callInfo);
     case InlinableNative::IntrinsicIsTypedArray:
       return inlineIsTypedArray(callInfo);
@@ -2907,22 +2926,20 @@ IonBuilder::InliningResult IonBuilder::i
     }
   }
 
   callInfo.setImplicitlyUsedUnchecked();
   return InliningStatus_Inlined;
 }
 
 IonBuilder::InliningResult IonBuilder::inlineGuardToClass(
-    CallInfo& callInfo, InlinableNative native) {
+    CallInfo& callInfo, const JSClass* clasp) {
   MOZ_ASSERT(!callInfo.constructing());
   MOZ_ASSERT(callInfo.argc() == 1);
 
-  const JSClass* clasp = InlinableNativeGuardToClass(native);
-
   if (callInfo.getArg(0)->type() != MIRType::Object) {
     return InliningStatus_NotInlined;
   }
 
   if (getInlineReturnType() != MIRType::Object) {
     return InliningStatus_NotInlined;
   }
 
--- a/js/src/jit/WarpCacheIRTranspiler.cpp
+++ b/js/src/jit/WarpCacheIRTranspiler.cpp
@@ -79,19 +79,16 @@ class MOZ_RAII WarpCacheIRTranspiler : p
 
   uintptr_t readStubWord(uint32_t offset) {
     return stubInfo_->getStubRawWord(stubData_, offset);
   }
 
   Shape* shapeStubField(uint32_t offset) {
     return reinterpret_cast<Shape*>(readStubWord(offset));
   }
-  const JSClass* classStubField(uint32_t offset) {
-    return reinterpret_cast<const JSClass*>(readStubWord(offset));
-  }
   JSString* stringStubField(uint32_t offset) {
     return reinterpret_cast<JSString*>(readStubWord(offset));
   }
   JSObject* objectStubField(uint32_t offset) {
     return reinterpret_cast<JSObject*>(readStubWord(offset));
   }
   int32_t int32StubField(uint32_t offset) {
     return static_cast<int32_t>(readStubWord(offset));
@@ -185,28 +182,16 @@ bool WarpCacheIRTranspiler::emitGuardCla
 
   auto* ins = MGuardToClass::New(alloc(), def, classp);
   add(ins);
 
   setOperand(objId, ins);
   return true;
 }
 
-bool WarpCacheIRTranspiler::emitGuardAnyClass(ObjOperandId objId,
-                                              uint32_t claspOffset) {
-  MDefinition* def = getOperand(objId);
-  const JSClass* classp = classStubField(claspOffset);
-
-  auto* ins = MGuardToClass::New(alloc(), def, classp);
-  add(ins);
-
-  setOperand(objId, ins);
-  return true;
-}
-
 bool WarpCacheIRTranspiler::emitGuardShape(ObjOperandId objId,
                                            uint32_t shapeOffset) {
   MDefinition* def = getOperand(objId);
   Shape* shape = shapeStubField(shapeOffset);
 
   auto* ins = MGuardShape::New(alloc(), def, shape);
   add(ins);
 
--- a/js/src/jit/moz.build
+++ b/js/src/jit/moz.build
@@ -40,17 +40,16 @@ UNIFIED_SOURCES += [
     'CacheIRSpewer.cpp',
     'CodeGenerator.cpp',
     'CompileWrappers.cpp',
     'Disassemble.cpp',
     'EdgeCaseAnalysis.cpp',
     'EffectiveAddressAnalysis.cpp',
     'ExecutableAllocator.cpp',
     'FoldLinearArithConstants.cpp',
-    'InlinableNatives.cpp',
     'InstructionReordering.cpp',
     'Ion.cpp',
     'IonAnalysis.cpp',
     'IonBuilder.cpp',
     'IonCacheIRCompiler.cpp',
     'IonCompileTask.cpp',
     'IonIC.cpp',
     'IonOptimizationLevels.cpp',