Bug 1583172 part 6 - Pass frame size to Ion's NewBaselineFrameInspector. r=tcampbell
☠☠ backed out by 3954181d6538 ☠ ☠
authorJan de Mooij <jdemooij@mozilla.com>
Tue, 01 Oct 2019 14:20:21 +0000
changeset 495898 690f3798bbaf714a472864559b3bc370081d4974
parent 495897 de54dcbfcf744acdd7a4539e1146a36cdeca84aa
child 495899 4f2cba0b03be7de53dda9534738cb872259dbf23
push id114140
push userdvarga@mozilla.com
push dateWed, 02 Oct 2019 18:04:51 +0000
treeherdermozilla-inbound@32eb0ea893f3 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerstcampbell
bugs1583172
milestone71.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 1583172 part 6 - Pass frame size to Ion's NewBaselineFrameInspector. r=tcampbell Differential Revision: https://phabricator.services.mozilla.com/D46917
js/src/jit/BaselineCodeGen.cpp
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineIC.h
js/src/jit/Ion.cpp
js/src/jit/Ion.h
js/src/jit/IonBuilder.cpp
js/src/jit/IonBuilder.h
js/src/jit/VMFunctionList-inl.h
--- a/js/src/jit/BaselineCodeGen.cpp
+++ b/js/src/jit/BaselineCodeGen.cpp
@@ -1320,34 +1320,34 @@ bool BaselineCompilerCodeGen::emitWarmUp
   masm.loadPtr(Address(scriptReg, JitScript::offsetOfIonScript()), scriptReg);
   masm.branchPtr(Assembler::Equal, scriptReg, ImmPtr(IonCompilingScriptPtr),
                  &skipCall);
   masm.branchPtr(Assembler::Equal, scriptReg, ImmPtr(IonDisabledScriptPtr),
                  &skipCall);
 
   // Try to compile and/or finish a compilation.
   if (JSOp(*pc) == JSOP_LOOPENTRY) {
-    // During the loop entry we can try to OSR into ion.
-    // The ic has logic for this.
+    // During the loop entry we can try to OSR into ion. The IC for this expects
+    // the frame size in R0.scratchReg().
+    computeFrameSize(R0.scratchReg());
     if (!emitNextIC()) {
       return false;
     }
   } else {
     // To call stubs we need to have an opcode. This code handles the
     // prologue and there is no dedicatd opcode present. Therefore use an
     // annotated vm call.
     prepareVMCall();
 
-    pushBytecodePCArg();
     masm.PushBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
 
     const RetAddrEntry::Kind kind = RetAddrEntry::Kind::WarmupCounter;
 
-    using Fn = bool (*)(JSContext*, BaselineFrame*, jsbytecode*);
-    if (!callVM<Fn, IonCompileScriptForBaseline>(kind)) {
+    using Fn = bool (*)(JSContext*, BaselineFrame*);
+    if (!callVM<Fn, IonCompileScriptForBaselineAtEntry>(kind)) {
       return false;
     }
   }
   masm.bind(&skipCall);
 
   return true;
 }
 
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -765,29 +765,28 @@ static void TryAttachStub(const char* na
 /* clang-format on */
 
 struct IonOsrTempData {
   void* jitcode;
   uint8_t* baselineFrame;
 };
 
 static IonOsrTempData* PrepareOsrTempData(JSContext* cx, BaselineFrame* frame,
-                                          void* jitcode) {
-  size_t numLocalsAndStackVals = frame->numValueSlots();
+                                          uint32_t frameSize, void* jitcode) {
+  uint32_t numValueSlots = frame->numValueSlots();
 
   // Calculate the amount of space to allocate:
   //      BaselineFrame space:
-  //          (sizeof(Value) * (numLocals + numStackVals))
+  //          (sizeof(Value) * numValueSlots)
   //        + sizeof(BaselineFrame)
   //
   //      IonOsrTempData space:
   //          sizeof(IonOsrTempData)
 
-  size_t frameSpace =
-      sizeof(BaselineFrame) + sizeof(Value) * numLocalsAndStackVals;
+  size_t frameSpace = sizeof(BaselineFrame) + sizeof(Value) * numValueSlots;
   size_t ionOsrTempDataSpace = sizeof(IonOsrTempData);
 
   size_t totalSpace = AlignBytes(frameSpace, sizeof(Value)) +
                       AlignBytes(ionOsrTempDataSpace, sizeof(Value));
 
   IonOsrTempData* info = (IonOsrTempData*)cx->allocateOsrTempData(totalSpace);
   if (!info) {
     ReportOutOfMemory(cx);
@@ -802,39 +801,42 @@ static IonOsrTempData* PrepareOsrTempDat
   // |this| are not copied but left on the stack: the Baseline and Ion frame
   // share the same frame prefix and Ion won't clobber these values. Note
   // that info->baselineFrame will point to the *end* of the frame data, like
   // the frame pointer register in baseline frames.
   uint8_t* frameStart =
       (uint8_t*)info + AlignBytes(ionOsrTempDataSpace, sizeof(Value));
   info->baselineFrame = frameStart + frameSpace;
 
-  memcpy(frameStart, (uint8_t*)frame - numLocalsAndStackVals * sizeof(Value),
+  memcpy(frameStart, (uint8_t*)frame - numValueSlots * sizeof(Value),
          frameSpace);
 
   JitSpew(JitSpew_BaselineOSR, "Allocated IonOsrTempData at %p", (void*)info);
   JitSpew(JitSpew_BaselineOSR, "Jitcode is %p", info->jitcode);
 
   // All done.
   return info;
 }
 
 bool DoWarmUpCounterFallbackOSR(JSContext* cx, BaselineFrame* frame,
+                                uint32_t frameSize,
                                 ICWarmUpCounter_Fallback* stub,
                                 IonOsrTempData** infoPtr) {
   MOZ_ASSERT(infoPtr);
   *infoPtr = nullptr;
 
+  MOZ_ASSERT(frame->frameSize() == frameSize);
+
   RootedScript script(cx, frame->script());
   jsbytecode* pc = stub->icEntry()->pc(script);
   MOZ_ASSERT(JSOp(*pc) == JSOP_LOOPENTRY);
 
   FallbackICSpew(cx, stub, "WarmUpCounter(%d)", int(script->pcToOffset(pc)));
 
-  if (!IonCompileScriptForBaseline(cx, frame, pc)) {
+  if (!IonCompileScriptForBaseline(cx, frame, frameSize, pc)) {
     return false;
   }
 
   if (!script->hasIonScript() || script->ionScript()->osrPc() != pc ||
       script->ionScript()->bailoutExpected() || frame->isDebuggee()) {
     return true;
   }
 
@@ -844,43 +846,45 @@ bool DoWarmUpCounterFallbackOSR(JSContex
   MOZ_ASSERT(ion->osrPc() == pc);
 
   JitSpew(JitSpew_BaselineOSR, "  OSR possible!");
   void* jitcode = ion->method()->raw() + ion->osrEntryOffset();
 
   // Prepare the temporary heap copy of the fake InterpreterFrame and actual
   // args list.
   JitSpew(JitSpew_BaselineOSR, "Got jitcode.  Preparing for OSR into ion.");
-  IonOsrTempData* info = PrepareOsrTempData(cx, frame, jitcode);
+  IonOsrTempData* info = PrepareOsrTempData(cx, frame, frameSize, jitcode);
   if (!info) {
     return false;
   }
   *infoPtr = info;
 
   return true;
 }
 
 bool FallbackICCodeCompiler::emit_WarmUpCounter() {
+  // Note: frame size is stored in R0.scratchReg().
+
   // Push a stub frame so that we can perform a non-tail call.
   enterStubFrame(masm, R1.scratchReg());
 
   Label noCompiledCode;
   // Call DoWarmUpCounterFallbackOSR to compile/check-for Ion-compiled function
   {
     // Push IonOsrTempData pointer storage
     masm.subFromStackPtr(Imm32(sizeof(void*)));
     masm.push(masm.getStackPointer());
 
-    // Push stub pointer.
+    // Push stub pointer, frame size, frame pointer.
     masm.push(ICStubReg);
-
+    masm.push(R0.scratchReg());
     pushStubPayload(masm, R0.scratchReg());
 
-    using Fn = bool (*)(JSContext*, BaselineFrame*, ICWarmUpCounter_Fallback*,
-                        IonOsrTempData * *infoPtr);
+    using Fn = bool (*)(JSContext*, BaselineFrame*, uint32_t,
+                        ICWarmUpCounter_Fallback*, IonOsrTempData**);
     if (!callVM<Fn, DoWarmUpCounterFallbackOSR>(masm)) {
       return false;
     }
 
     // Pop IonOsrTempData pointer.
     masm.pop(R0.scratchReg());
 
     leaveStubFrame(masm);
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -1857,16 +1857,17 @@ extern MOZ_MUST_USE bool TypeMonitorResu
                                            HandleScript script, jsbytecode* pc,
                                            HandleValue val);
 
 extern bool DoTypeUpdateFallback(JSContext* cx, BaselineFrame* frame,
                                  ICCacheIR_Updated* stub, HandleValue objval,
                                  HandleValue value);
 
 extern bool DoWarmUpCounterFallbackOSR(JSContext* cx, BaselineFrame* frame,
+                                       uint32_t frameSize,
                                        ICWarmUpCounter_Fallback* stub,
                                        IonOsrTempData** infoPtr);
 
 extern bool DoCallFallback(JSContext* cx, BaselineFrame* frame,
                            ICCall_Fallback* stub, uint32_t argc, Value* vp,
                            MutableHandleValue res);
 
 extern bool DoSpreadCallFallback(JSContext* cx, BaselineFrame* frame,
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -1726,17 +1726,18 @@ static void TrackIonAbort(JSContext* cx,
 
 static void TrackAndSpewIonAbort(JSContext* cx, JSScript* script,
                                  const char* message) {
   JitSpew(JitSpew_IonAbort, "%s", message);
   TrackIonAbort(cx, script, script->code(), message);
 }
 
 static AbortReason IonCompile(JSContext* cx, JSScript* script,
-                              BaselineFrame* baselineFrame, jsbytecode* osrPc,
+                              BaselineFrame* baselineFrame,
+                              uint32_t baselineFrameSize, jsbytecode* osrPc,
                               bool recompile,
                               OptimizationLevel optimizationLevel) {
   TraceLoggerThread* logger = TraceLoggerForCurrentThread(cx);
   TraceLoggerEvent event(TraceLogger_AnnotateScripts, script);
   AutoTraceLog logScript(logger, event);
   AutoTraceLog logCompile(logger, TraceLogger_IonCompilation);
 
   cx->check(script);
@@ -1787,17 +1788,18 @@ static AbortReason IonCompile(JSContext*
 
   BaselineInspector* inspector = alloc->new_<BaselineInspector>(script);
   if (!inspector) {
     return AbortReason::Alloc;
   }
 
   BaselineFrameInspector* baselineFrameInspector = nullptr;
   if (baselineFrame) {
-    baselineFrameInspector = NewBaselineFrameInspector(temp, baselineFrame);
+    baselineFrameInspector =
+        NewBaselineFrameInspector(temp, baselineFrame, baselineFrameSize);
     if (!baselineFrameInspector) {
       return AbortReason::Alloc;
     }
   }
 
   CompilerConstraintList* constraints = NewCompilerConstraintList(*temp);
   if (!constraints) {
     return AbortReason::Alloc;
@@ -2060,18 +2062,18 @@ bool CanIonInlineScript(JSScript* script
 }
 
 static OptimizationLevel GetOptimizationLevel(HandleScript script,
                                               jsbytecode* pc) {
   return IonOptimizations.levelForScript(script, pc);
 }
 
 static MethodStatus Compile(JSContext* cx, HandleScript script,
-                            BaselineFrame* osrFrame, jsbytecode* osrPc,
-                            bool forceRecompile = false) {
+                            BaselineFrame* osrFrame, uint32_t osrFrameSize,
+                            jsbytecode* osrPc, bool forceRecompile = false) {
   MOZ_ASSERT(jit::IsIonEnabled());
   MOZ_ASSERT(jit::IsBaselineJitEnabled());
   MOZ_ASSERT_IF(osrPc != nullptr, LoopEntryCanIonOsr(osrPc));
   AutoGeckoProfilerEntry pseudoFrame(
       cx, "Ion script compilation",
       JS::ProfilingCategoryPair::JS_IonCompilation);
 
   if (!script->hasBaselineScript()) {
@@ -2124,18 +2126,18 @@ static MethodStatus Compile(JSContext* c
 
     if (osrPc) {
       scriptIon->resetOsrPcMismatchCounter();
     }
 
     recompile = true;
   }
 
-  AbortReason reason =
-      IonCompile(cx, script, osrFrame, osrPc, recompile, optimizationLevel);
+  AbortReason reason = IonCompile(cx, script, osrFrame, osrFrameSize, osrPc,
+                                  recompile, optimizationLevel);
   if (reason == AbortReason::Error) {
     MOZ_ASSERT(cx->isExceptionPending());
     return Method_Error;
   }
 
   if (reason == AbortReason::Disable) {
     return Method_CantCompile;
   }
@@ -2215,17 +2217,19 @@ MethodStatus jit::CanEnterIon(JSContext*
       return status;
     }
   }
 
   MOZ_ASSERT(!script->isIonCompilingOffThread());
   MOZ_ASSERT(script->canIonCompile());
 
   // Attempt compilation. Returns Method_Compiled if already compiled.
-  MethodStatus status = Compile(cx, script, nullptr, nullptr);
+  MethodStatus status =
+      Compile(cx, script, /* osrFrame = */ nullptr, /* osrFrameSize = */ 0,
+              /* osrPc = */ nullptr);
   if (status != Method_Compiled) {
     if (status == Method_CantCompile) {
       ForbidCompilation(cx, script);
     }
     return status;
   }
 
   if (state.script()->baselineScript()->hasPendingIonBuilder()) {
@@ -2234,45 +2238,47 @@ MethodStatus jit::CanEnterIon(JSContext*
       return jit::Method_Skipped;
     }
   }
 
   return Method_Compiled;
 }
 
 static MethodStatus BaselineCanEnterAtEntry(JSContext* cx, HandleScript script,
-                                            BaselineFrame* frame) {
+                                            BaselineFrame* frame,
+                                            uint32_t frameSize) {
   MOZ_ASSERT(jit::IsIonEnabled());
-  MOZ_ASSERT(frame->callee()->nonLazyScript()->canIonCompile());
-  MOZ_ASSERT(!frame->callee()->nonLazyScript()->isIonCompilingOffThread());
-  MOZ_ASSERT(!frame->callee()->nonLazyScript()->hasIonScript());
+  MOZ_ASSERT(script->canIonCompile());
+  MOZ_ASSERT(!script->isIonCompilingOffThread());
+  MOZ_ASSERT(!script->hasIonScript());
   MOZ_ASSERT(frame->isFunctionFrame());
 
   // Mark as forbidden if frame can't be handled.
   if (!CheckFrame(cx, frame)) {
     ForbidCompilation(cx, script);
     return Method_CantCompile;
   }
 
   // Attempt compilation. Returns Method_Compiled if already compiled.
-  MethodStatus status = Compile(cx, script, frame, nullptr);
+  MethodStatus status = Compile(cx, script, frame, frameSize, nullptr);
   if (status != Method_Compiled) {
     if (status == Method_CantCompile) {
       ForbidCompilation(cx, script);
     }
     return status;
   }
 
   return Method_Compiled;
 }
 
 // Decide if a transition from baseline execution to Ion code should occur.
 // May compile or recompile the target JSScript.
 static MethodStatus BaselineCanEnterAtBranch(JSContext* cx, HandleScript script,
                                              BaselineFrame* osrFrame,
+                                             uint32_t osrFrameSize,
                                              jsbytecode* pc) {
   MOZ_ASSERT(jit::IsIonEnabled());
   MOZ_ASSERT((JSOp)*pc == JSOP_LOOPENTRY);
   MOZ_ASSERT(LoopEntryCanIonOsr(pc));
 
   // Skip if the script has been disabled.
   if (!script->canIonCompile()) {
     return Method_Skipped;
@@ -2317,17 +2323,17 @@ static MethodStatus BaselineCanEnterAtBr
   }
 
   // Attempt compilation.
   // - Returns Method_Compiled if the right ionscript is present
   //   (Meaning it was present or a sequantial compile finished)
   // - Returns Method_Skipped if pc doesn't match
   //   (This means a background thread compilation with that pc could have
   //   started or not.)
-  MethodStatus status = Compile(cx, script, osrFrame, pc, force);
+  MethodStatus status = Compile(cx, script, osrFrame, osrFrameSize, pc, force);
   if (status != Method_Compiled) {
     if (status == Method_CantCompile) {
       ForbidCompilation(cx, script);
     }
     return status;
   }
 
   // Return the compilation was skipped when the osr pc wasn't adjusted.
@@ -2337,18 +2343,19 @@ static MethodStatus BaselineCanEnterAtBr
   if (script->hasIonScript() && pc != script->ionScript()->osrPc()) {
     return Method_Skipped;
   }
 
   return Method_Compiled;
 }
 
 bool jit::IonCompileScriptForBaseline(JSContext* cx, BaselineFrame* frame,
-                                      jsbytecode* pc) {
+                                      uint32_t frameSize, jsbytecode* pc) {
   MOZ_ASSERT(IsIonEnabled());
+  MOZ_ASSERT(frame->frameSize() == frameSize);
 
   RootedScript script(cx, frame->script());
   bool isLoopEntry = JSOp(*pc) == JSOP_LOOPENTRY;
 
   MOZ_ASSERT(!isLoopEntry || LoopEntryCanIonOsr(pc));
 
   // The Baseline JIT code checks for Ion disabled or compiling off-thread.
   MOZ_ASSERT(script->canIonCompile());
@@ -2371,21 +2378,21 @@ bool jit::IonCompileScriptForBaseline(JS
           "Ion!",
           script->filename(), script->lineno(), script->column(),
           (int)script->getWarmUpCount(), (void*)pc);
 
   MethodStatus stat;
   if (isLoopEntry) {
     MOZ_ASSERT(LoopEntryCanIonOsr(pc));
     JitSpew(JitSpew_BaselineOSR, "  Compile at loop entry!");
-    stat = BaselineCanEnterAtBranch(cx, script, frame, pc);
+    stat = BaselineCanEnterAtBranch(cx, script, frame, frameSize, pc);
   } else if (frame->isFunctionFrame()) {
     JitSpew(JitSpew_BaselineOSR,
             "  Compile function from top for later entry!");
-    stat = BaselineCanEnterAtEntry(cx, script, frame);
+    stat = BaselineCanEnterAtEntry(cx, script, frame, frameSize);
   } else {
     return true;
   }
 
   if (stat == Method_Error) {
     JitSpew(JitSpew_BaselineOSR, "  Compile with Ion errored!");
     return false;
   }
@@ -2414,25 +2421,34 @@ bool jit::IonCompileScriptForBaseline(JS
       script->resetWarmUpCounterToDelayIonCompilation();
     }
     return true;
   }
 
   return true;
 }
 
+bool jit::IonCompileScriptForBaselineAtEntry(JSContext* cx,
+                                             BaselineFrame* frame) {
+  JSScript* script = frame->script();
+  uint32_t frameSize =
+      BaselineFrame::frameSizeForNumValueSlots(script->nfixed());
+  return IonCompileScriptForBaseline(cx, frame, frameSize, script->code());
+}
+
 MethodStatus jit::Recompile(JSContext* cx, HandleScript script, bool force) {
   MOZ_ASSERT(script->hasIonScript());
   if (script->ionScript()->isRecompiling()) {
     return Method_Compiled;
   }
 
   MOZ_ASSERT(!script->baselineScript()->hasPendingIonBuilder());
 
   MethodStatus status = Compile(cx, script, /* osrFrame = */ nullptr,
+                                /* osrFrameSize = */ 0,
                                 /* osrPc = */ nullptr, force);
   if (status != Method_Compiled) {
     if (status == Method_CantCompile) {
       ForbidCompilation(cx, script);
     }
     return status;
   }
 
--- a/js/src/jit/Ion.h
+++ b/js/src/jit/Ion.h
@@ -137,18 +137,22 @@ JitContext* MaybeGetJitContext();
 
 void SetJitContext(JitContext* ctx);
 
 bool CanIonCompileScript(JSContext* cx, JSScript* script);
 bool CanIonInlineScript(JSScript* script);
 
 MOZ_MUST_USE bool IonCompileScriptForBaseline(JSContext* cx,
                                               BaselineFrame* frame,
+                                              uint32_t frameSize,
                                               jsbytecode* pc);
 
+MOZ_MUST_USE bool IonCompileScriptForBaselineAtEntry(JSContext* cx,
+                                                     BaselineFrame* frame);
+
 MethodStatus CanEnterIon(JSContext* cx, RunState& state);
 
 MethodStatus Recompile(JSContext* cx, HandleScript script, bool force);
 
 enum JitExecStatus {
   // The method call had to be aborted due to a stack limit check. This
   // error indicates that Ion never attempted to clean up frames.
   JitExec_Aborted,
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -62,17 +62,18 @@ class jit::BaselineFrameInspector {
   explicit BaselineFrameInspector(TempAllocator* temp)
       : thisType(TypeSet::UndefinedType()),
         singletonEnvChain(nullptr),
         argTypes(*temp),
         varTypes(*temp) {}
 };
 
 BaselineFrameInspector* jit::NewBaselineFrameInspector(TempAllocator* temp,
-                                                       BaselineFrame* frame) {
+                                                       BaselineFrame* frame,
+                                                       uint32_t frameSize) {
   MOZ_ASSERT(frame);
 
   BaselineFrameInspector* inspector =
       temp->lifoAlloc()->new_<BaselineFrameInspector>(temp);
   if (!inspector) {
     return nullptr;
   }
 
@@ -107,20 +108,21 @@ BaselineFrameInspector* jit::NewBaseline
             TypeSet::GetMaybeUntrackedValueType(frame->argsObj().arg(i));
         inspector->argTypes.infallibleAppend(type);
       } else {
         inspector->argTypes.infallibleAppend(TypeSet::UndefinedType());
       }
     }
   }
 
-  if (!inspector->varTypes.reserve(frame->numValueSlots())) {
+  uint32_t numValueSlots = frame->numValueSlots();
+  if (!inspector->varTypes.reserve(numValueSlots)) {
     return nullptr;
   }
-  for (size_t i = 0; i < frame->numValueSlots(); i++) {
+  for (size_t i = 0; i < numValueSlots; i++) {
     TypeSet::Type type =
         TypeSet::GetMaybeUntrackedValueType(*frame->valueSlot(i));
     inspector->varTypes.infallibleAppend(type);
   }
 
   return inspector;
 }
 
--- a/js/src/jit/IonBuilder.h
+++ b/js/src/jit/IonBuilder.h
@@ -34,17 +34,18 @@ class CodeGenerator;
 class CallInfo;
 class BaselineFrameInspector;
 
 enum class InlinableNative : uint16_t;
 
 // Records information about a baseline frame for compilation that is stable
 // when later used off thread.
 BaselineFrameInspector* NewBaselineFrameInspector(TempAllocator* temp,
-                                                  BaselineFrame* frame);
+                                                  BaselineFrame* frame,
+                                                  uint32_t frameSize);
 
 using CallTargets = Vector<JSFunction*, 6, JitAllocPolicy>;
 
 class IonBuilder : public MIRGenerator,
                    public mozilla::LinkedListElement<IonBuilder>,
                    public RunnableTask {
  public:
   IonBuilder(JSContext* analysisContext, CompileRealm* realm,
--- a/js/src/jit/VMFunctionList-inl.h
+++ b/js/src/jit/VMFunctionList-inl.h
@@ -140,17 +140,18 @@ namespace jit {
   _(Int32ToString, js::Int32ToString<CanGC>)                                   \
   _(InterpretResume, js::jit::InterpretResume)                                 \
   _(InterruptCheck, js::jit::InterruptCheck)                                   \
   _(InvokeFunction, js::jit::InvokeFunction)                                   \
   _(InvokeFunctionShuffleNewTarget, js::jit::InvokeFunctionShuffleNewTarget)   \
   _(IonBinaryArithICUpdate, js::jit::IonBinaryArithIC::update)                 \
   _(IonBindNameICUpdate, js::jit::IonBindNameIC::update)                       \
   _(IonCompareICUpdate, js::jit::IonCompareIC::update)                         \
-  _(IonCompileScriptForBaseline, js::jit::IonCompileScriptForBaseline)         \
+  _(IonCompileScriptForBaselineAtEntry,                                        \
+    js::jit::IonCompileScriptForBaselineAtEntry)                               \
   _(IonForcedInvalidation, js::jit::IonForcedInvalidation)                     \
   _(IonForcedRecompile, js::jit::IonForcedRecompile)                           \
   _(IonGetIteratorICUpdate, js::jit::IonGetIteratorIC::update)                 \
   _(IonGetNameICUpdate, js::jit::IonGetNameIC::update)                         \
   _(IonGetPropSuperICUpdate, js::jit::IonGetPropSuperIC::update)               \
   _(IonGetPropertyICUpdate, js::jit::IonGetPropertyIC::update)                 \
   _(IonHasOwnICUpdate, js::jit::IonHasOwnIC::update)                           \
   _(IonInICUpdate, js::jit::IonInIC::update)                                   \