Set driver progress callback, for backend issue 2391

devtools/server/actors/replay/module.js

@@ -537,6 +537,7 @@ const commands = {
   "Target.getCurrentMessageContents": Target_getCurrentMessageContents,
   "Target.getFunctionsInRange": Target_getFunctionsInRange,
   "Target.getHTMLSource": Target_getHTMLSource,
+  "Target.getStackFunctionIDs": Target_getStackFunctionIDs,
   "Target.getStepOffsets": Target_getStepOffsets,
   "Target.getSourceMapURL": Target_getSourceMapURL,
   "Target.getSheetSourceMapURL": Target_getSheetSourceMapURL,
@@ -897,6 +898,14 @@ function Target_getFunctionsInRange({ sourceId, begin, end }) {
   return { functions };
 }
 
+function Target_getStackFunctionIDs() {
+  const rv = [];
+  forEachScriptFrame(frame => {
+    rv.push(scriptToFunctionId(frame.script));
+  });
+  return { frameFunctions: rv.reverse() };
+}
+
 function Target_getStepOffsets({ functionId }) {
   const script = functionIdToScript(functionId);
   const offsets = script

js/src/jit/BaselineCodeGen.cpp

@@ -2138,6 +2138,25 @@ bool BaselineCodeGen<Handler>::emit_ExecutionProgress() {
       masm.maybeCallExecutionProgressHook(scratch);
     }
     masm.inc64(AbsoluteAddress(ExecutionProgressCounter()));
+    if (mozilla::recordreplay::IsReplaying()) {
+      frame.syncStack(0);
+
+      Register scratch = R0.scratchReg();
+      Label done;
+
+      masm.loadPtr(AbsoluteAddress(ExecutionProgressTarget()), scratch);
+      masm.branchPtr(Assembler::Equal, scratch, ImmPtr(nullptr), &done);
+      masm.branchPtr(Assembler::NotEqual, AbsoluteAddress(ExecutionProgressCounter()),
+                     scratch, &done);
+
+      prepareVMCall();
+      using Fn = bool (*)(JSContext*);
+      if (!callVM<Fn, RecordReplayProgressReached>()) {
+        return false;
+      }
+
+      masm.bind(&done);
+    }
   }
   return true;
 }

js/src/jit/CodeGenerator.cpp

@@ -13868,6 +13868,19 @@ void CodeGenerator::visitInterruptCheck(LInterruptCheck* lir) {
 void CodeGenerator::visitExecutionProgress(LExecutionProgress* lir) {
   masm.maybeCallExecutionProgressHook(lir->mir()->script());
   masm.inc64(AbsoluteAddress(ExecutionProgressCounter()));
+
+  if (mozilla::recordreplay::IsReplaying()) {
+    using Fn = bool (*)(JSContext*);
+    OutOfLineCode* ool =
+      oolCallVM<Fn, RecordReplayProgressReached>(lir, ArgList(), StoreNothing());
+
+    Register tmp = ToRegister(lir->scratch());
+    masm.loadPtr(AbsoluteAddress(ExecutionProgressTarget()), tmp);
+    masm.branchPtr(Assembler::Equal, tmp, ImmPtr(nullptr), ool->rejoin());
+    masm.branchPtr(Assembler::Equal, AbsoluteAddress(ExecutionProgressCounter()),
+                   tmp, ool->entry());
+    masm.bind(ool->rejoin());
+  }
 }
 
 void CodeGenerator::visitWasmInterruptCheck(LWasmInterruptCheck* lir) {

js/src/jit/VMFunctionList-inl.h

@@ -144,6 +144,7 @@ namespace jit {
   _(Int32ToString, js::Int32ToString<CanGC>)                                   \
   _(InterpretResume, js::jit::InterpretResume)                                 \
   _(InterruptCheck, js::jit::InterruptCheck)                                   \
+  _(RecordReplayProgressReached, js::RecordReplayProgressReached)              \
   _(InvokeFunction, js::jit::InvokeFunction)                                   \
   _(IonBinaryArithICUpdate, js::jit::IonBinaryArithIC::update)                 \
   _(IonBindNameICUpdate, js::jit::IonBindNameIC::update)                       \

js/src/jit/shared/LIR-shared.h

@@ -629,12 +629,14 @@ class LInterruptCheck : public LInstructionHelper<0, 0, 0> {
   MInterruptCheck* mir() const { return mir_->toInterruptCheck(); }
 };
 
-class LExecutionProgress : public LInstructionHelper<0, 0, 0> {
+class LExecutionProgress : public LInstructionHelper<0, 0, 1> {
  public:
   LIR_HEADER(ExecutionProgress)
 
   LExecutionProgress() : LInstructionHelper(classOpcode) {}
   MExecutionProgress* mir() const { return mir_->toExecutionProgress(); }
+
+  const LDefinition* scratch() { return getTemp(0); }
 };
 
 class LWasmInterruptCheck : public LInstructionHelper<0, 1, 0> {

js/src/vm/Initialization.cpp

@@ -249,6 +249,9 @@ JS_PUBLIC_API const char* JS::detail::InitWithFailureDiagnostic(
   if (getenv("RECORD_REPLAY_FORCE_RECORD_JS_ASSERTS")) {
     gForceEmitRecordReplayAsserts = true;
   }
+  if (mozilla::recordreplay::IsReplaying()) {
+    mozilla::recordreplay::SetExecutionProgressCallback(SetExecutionProgressTargetCallback);
+  }
 #endif
 
   libraryInitState = InitState::Running;

js/src/vm/Runtime.cpp

@@ -916,12 +916,31 @@ uint64_t* js::ExecutionProgressCounter() {
     : mozilla::recordreplay::ExecutionProgressCounter();
 }
 
+static uint64_t gExecutionProgressTarget;
+
 void js::AdvanceExecutionProgressCounter() {
   if (!gForceEmitExecutionProgress) {
     mozilla::recordreplay::AdvanceExecutionProgressCounter();
+    if (*ExecutionProgressCounter() == gExecutionProgressTarget) {
+      mozilla::recordreplay::ExecutionProgressReached();
+    }
   }
 }
 
+uint64_t* js::ExecutionProgressTarget() {
+  return &gExecutionProgressTarget;
+}
+
+void js::SetExecutionProgressTargetCallback(uint64_t aProgress) {
+  MOZ_RELEASE_ASSERT(mozilla::recordreplay::IsReplaying());
+  gExecutionProgressTarget = aProgress;
+}
+
+bool js::RecordReplayProgressReached(JSContext* cx) {
+  mozilla::recordreplay::ExecutionProgressReached();
+  return true;
+}
+
 bool js::RecordReplayAssertValue(JSContext* cx, HandlePropertyName name, HandleValue value) {
   if (!mozilla::recordreplay::IsRecordingOrReplaying()) {
     MOZ_RELEASE_ASSERT(gForceEmitRecordReplayAsserts);

js/src/vm/Runtime.h

@@ -1225,9 +1225,19 @@ extern bool gRecordDataBuffers;
 extern bool gForceEmitExecutionProgress;
 extern bool gForceEmitRecordReplayAsserts;
 
+// Current value of the record/replay progress counter.
 extern uint64_t* ExecutionProgressCounter();
 extern void AdvanceExecutionProgressCounter();
 
+// Any progress value at which we need to notify the record/replay driver when reaching.
+extern uint64_t* ExecutionProgressTarget();
+
+// Callback used by the record/replay driver to set a progress to run to.
+extern void SetExecutionProgressTargetCallback(uint64_t aProgress);
+
+// Called when the target progress has been reached.
+extern bool RecordReplayProgressReached(JSContext* cx);
+
 extern bool ShouldEmitRecordReplayAssert(const char* aFilename,
                                          unsigned aLineno, unsigned aColumn);
 

mfbt/RecordReplay.cpp

@@ -78,6 +78,8 @@ namespace recordreplay {
         (aToken, aBuffer, aLength))                                            \
   Macro(EndContentParse, (const void* aToken), (aToken))                       \
   Macro(AdvanceExecutionProgressCounter, (), ())                               \
+  Macro(SetExecutionProgressCallback, (void (*aCallback)(uint64_t)), (aCallback)) \
+  Macro(ExecutionProgressReached, (), ())                                      \
   Macro(InternalAssertScriptedCaller, (const char* aWhy), (aWhy))
 // clang-format on
 

mfbt/RecordReplay.h

@@ -246,6 +246,12 @@ MFBT_API ProgressCounter* ExecutionProgressCounter();
 // Advance the execution progress counter.
 MFBT_API void AdvanceExecutionProgressCounter();
 
+// Set a callback the driver can use to set a destination progress value.
+MFBT_API void SetExecutionProgressCallback(void (*aCallback)(uint64_t));
+
+// Called when the last destination progress value which was set has been reached.
+MFBT_API void ExecutionProgressReached();
+
 // Get an identifier for the current execution point which can be used to warp
 // here later.
 MFBT_API ProgressCounter NewTimeWarpTarget();

toolkit/recordreplay/ProcessRecordReplay.cpp

@@ -75,6 +75,8 @@ static void (*gAssert)(const char* format, va_list);
 static void (*gAssertBytes)(const char* why, const void*, size_t);
 static void (*gFinishRecording)();
 static uint64_t* (*gProgressCounter)();
+static void (*gSetProgressCallback)(void (*aCallback)(uint64_t));
+static void (*gProgressReached)();
 static void (*gBeginPassThroughEvents)();
 static void (*gEndPassThroughEvents)();
 static bool (*gAreEventsPassedThrough)();
@@ -192,6 +194,8 @@ MOZ_EXPORT void RecordReplayInterface_Initialize(int* aArgc, char*** aArgv) {
   LoadSymbol("RecordReplayAssert", gAssert);
   LoadSymbol("RecordReplayAssertBytes", gAssertBytes);
   LoadSymbol("RecordReplayProgressCounter", gProgressCounter);
+  LoadSymbol("RecordReplaySetProgressCallback", gSetProgressCallback, /* aOptional */ true);
+  LoadSymbol("RecordReplayProgressReached", gProgressReached, /* aOptional */ true);
   LoadSymbol("RecordReplayBeginPassThroughEvents", gBeginPassThroughEvents);
   LoadSymbol("RecordReplayEndPassThroughEvents", gEndPassThroughEvents);
   LoadSymbol("RecordReplayAreEventsPassedThrough", gAreEventsPassedThrough);
@@ -348,6 +352,16 @@ MOZ_EXPORT void RecordReplayInterface_AdvanceExecutionProgressCounter() {
   ++*gProgressCounter();
 }
 
+MOZ_EXPORT void RecordReplayInterface_SetExecutionProgressCallback(void (*aCallback)(uint64_t)) {
+  if (gSetProgressCallback) {
+    gSetProgressCallback(aCallback);
+  }
+}
+
+MOZ_EXPORT void RecordReplayInterface_ExecutionProgressReached() {
+  gProgressReached();
+}
+
 MOZ_EXPORT void RecordReplayInterface_InternalBeginPassThroughThreadEvents() {
   gBeginPassThroughEvents();
 }