Support non-default MicrotaskQueue on RunMicrotasks builtin

The previous implementation of MicrotaskQueue::RunMicrotasks() didn't
support non-default MicrotaskQueue as RunMicrotasks builtin couldn't
take a parameter.

This CL updates the entry trampoline for RunMicrotasks builtin to pass
a MicrotaskQueue parameter to support non-default one.

Bug: v8:8124
Change-Id: I817238cd9a1fd6c20dcd58022274736c5e86229a
Reviewed-on: https://chromium-review.googlesource.com/c/1369906Reviewed-by: Sigurd Schneider <sigurds@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58872}

src/builtins/arm/builtins-arm.cc

@@ -537,19 +537,27 @@ constexpr int kPushedStackSpace = kNumCalleeSaved * kPointerSize +
                                   EntryFrameConstants::kCallerFPOffset;
 
 // Called with the native C calling convention. The corresponding function
-// signature is:
+// signature is either:
 //
-//  using JSEntryFunction = GeneratedCode<Address(
-//      Address root_register_value, Address new_target, Address target,
-//      Address receiver, intptr_t argc, Address** args)>;
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, Address new_target, Address target,
+//       Address receiver, intptr_t argc, Address** argv)>;
+// or
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, MicrotaskQueue* microtask_queue)>;
 void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
                              Builtins::Name entry_trampoline) {
-  // r0:                            root_register_value
-  // r1:                            code entry
-  // r2:                            function
-  // r3:                            receiver
-  // [sp + 0 * kSystemPointerSize]: argc
-  // [sp + 1 * kSystemPointerSize]: argv
+  // The register state is either:
+  //   r0:                            root_register_value
+  //   r1:                            code entry
+  //   r2:                            function
+  //   r3:                            receiver
+  //   [sp + 0 * kSystemPointerSize]: argc
+  //   [sp + 1 * kSystemPointerSize]: argv
+  // or
+  //   r0: root_register_value
+  //   r1: microtask_queue
+  // Preserve all but r0 and pass them to entry_trampoline.
   Label invoke, handler_entry, exit;
 
   // Update |pushed_stack_space| when we manipulate the stack.
@@ -578,9 +586,6 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
 
   // Push a frame with special values setup to mark it as an entry frame.
   // r0: root_register_value
-  // r1: code entry
-  // r2: function
-  // r3: receiver
   __ mov(r7, Operand(StackFrame::TypeToMarker(type)));
   __ mov(r6, Operand(StackFrame::TypeToMarker(type)));
   __ Move(r5, ExternalReference::Create(IsolateAddressId::kCEntryFPAddress,
@@ -654,13 +659,6 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
   // restores all kCalleeSaved registers (including cp and fp) to their
   // saved values before returning a failure to C.
   //
-  // Expected registers by Builtins::JSEntryTrampoline
-  // r0: code entry
-  // r1: function
-  // r2: receiver
-  // r3: argc
-  // r4: argv
-  //
   // Invoke the function by calling through JS entry trampoline builtin and
   // pop the faked function when we return.
   Handle<Code> trampoline_code =
@@ -717,7 +715,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
@@ -825,6 +824,16 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // This expects two C++ function parameters passed by Invoke() in
+  // execution.cc.
+  //   r0: root_register_value
+  //   r1: microtask_queue
+
+  __ mov(RunMicrotasksDescriptor::MicrotaskQueueRegister(), r1);
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void ReplaceClosureCodeWithOptimizedCode(
     MacroAssembler* masm, Register optimized_code, Register closure,
     Register scratch1, Register scratch2, Register scratch3) {

src/builtins/arm64/builtins-arm64.cc

@@ -594,19 +594,25 @@ void Builtins::Generate_ResumeGeneratorTrampoline(MacroAssembler* masm) {
 namespace {
 
 // Called with the native C calling convention. The corresponding function
-// signature is:
+// signature is either:
 //
-//  using JSEntryFunction = GeneratedCode<Address(
-//      Address root_register_value, Address new_target, Address target,
-//      Address receiver, intptr_t argc, Address** argv)>;
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, Address new_target, Address target,
+//       Address receiver, intptr_t argc, Address** argv)>;
+// or
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, MicrotaskQueue* microtask_queue)>;
 //
-// Input:
+// Input is either:
 //   x0: root_register_value.
 //   x1: new_target.
 //   x2: target.
 //   x3: receiver.
 //   x4: argc.
 //   x5: argv.
+// or
+//   x0: root_register_value.
+//   x1: microtask_queue.
 // Output:
 //   x0: result.
 void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
@@ -727,13 +733,6 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
   // restores all callee-saved registers (including cp and fp) to their
   // saved values before returning a failure to C.
   //
-  // Expected registers by Builtins::JSEntryTrampoline
-  // x1: new_target.
-  // x2: target.
-  // x3: receiver.
-  // x4: argc.
-  // x5: argv.
-  //
   // Invoke the function by calling through JS entry trampoline builtin and
   // pop the faked function when we return.
   Handle<Code> trampoline_code =
@@ -799,7 +798,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 // Input:
@@ -922,6 +922,16 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // This expects two C++ function parameters passed by Invoke() in
+  // execution.cc.
+  //   x0: root_register_value
+  //   x1: microtask_queue
+
+  __ Mov(RunMicrotasksDescriptor::MicrotaskQueueRegister(), x1);
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void ReplaceClosureCodeWithOptimizedCode(
     MacroAssembler* masm, Register optimized_code, Register closure,
     Register scratch1, Register scratch2, Register scratch3) {

src/builtins/builtins-definitions.h

@@ -252,6 +252,7 @@ namespace internal {
                                                                                \
   /* Microtask helpers */                                                      \
   TFS(EnqueueMicrotask, kMicrotask)                                            \
+  ASM(RunMicrotasksTrampoline, Dummy)                                          \
   TFC(RunMicrotasks, RunMicrotasks, 1)                                         \
                                                                                \
   /* Object property helpers */                                                \

src/builtins/builtins-microtask-queue-gen.cc

@@ -21,7 +21,6 @@ class MicrotaskQueueBuiltinsAssembler : public CodeStubAssembler {
   explicit MicrotaskQueueBuiltinsAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
-  TNode<RawPtrT> GetDefaultMicrotaskQueue();
   TNode<RawPtrT> GetMicrotaskQueue(TNode<Context> context);
   TNode<RawPtrT> GetMicrotaskRingBuffer(TNode<RawPtrT> microtask_queue);
   TNode<IntPtrT> GetMicrotaskQueueCapacity(TNode<RawPtrT> microtask_queue);
@@ -48,12 +47,6 @@ class MicrotaskQueueBuiltinsAssembler : public CodeStubAssembler {
                       SloppyTNode<HeapObject> promise_or_capability);
 };
 
-TNode<RawPtrT> MicrotaskQueueBuiltinsAssembler::GetDefaultMicrotaskQueue() {
-  auto ref = ExternalReference::default_microtask_queue_address(isolate());
-  return UncheckedCast<RawPtrT>(
-      Load(MachineType::Pointer(), ExternalConstant(ref)));
-}
-
 TNode<RawPtrT> MicrotaskQueueBuiltinsAssembler::GetMicrotaskQueue(
     TNode<Context> native_context) {
   CSA_ASSERT(this, IsNativeContext(native_context));
@@ -506,8 +499,8 @@ TF_BUILTIN(RunMicrotasks, MicrotaskQueueBuiltinsAssembler) {
   // Load the current context from the isolate.
   TNode<Context> current_context = GetCurrentContext();
 
-  // TODO(tzik): Take a MicrotaskQueue parameter to support non-default queue.
-  TNode<RawPtrT> microtask_queue = GetDefaultMicrotaskQueue();
+  TNode<RawPtrT> microtask_queue =
+      UncheckedCast<RawPtrT>(Parameter(Descriptor::kMicrotaskQueue));
 
   Label loop(this), done(this);
   Goto(&loop);

src/builtins/ia32/builtins-ia32.cc

@@ -371,11 +371,14 @@ void Builtins::Generate_ConstructedNonConstructable(MacroAssembler* masm) {
 namespace {
 
 // Called with the native C calling convention. The corresponding function
-// signature is:
+// signature is either:
 //
-//  using JSEntryFunction = GeneratedCode<Address(
-//      Address root_register_value, Address new_target, Address target,
-//      Address receiver, intptr_t argc, Address** args)>;
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, Address new_target, Address target,
+//       Address receiver, intptr_t argc, Address** argv)>;
+// or
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, MicrotaskQueue* microtask_queue)>;
 void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
                              Builtins::Name entry_trampoline) {
   Label invoke, handler_entry, exit;
@@ -493,7 +496,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
@@ -574,6 +578,15 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // This expects two C++ function parameters passed by Invoke() in
+  // execution.cc.
+  //   r1: microtask_queue
+  __ mov(RunMicrotasksDescriptor::MicrotaskQueueRegister(),
+         Operand(ebp, EntryFrameConstants::kMicrotaskQueueArgOffset));
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void GetSharedFunctionInfoBytecode(MacroAssembler* masm,
                                           Register sfi_data,
                                           Register scratch1) {

src/builtins/mips/builtins-mips.cc

@@ -568,7 +568,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
@@ -665,6 +666,12 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // a1: microtask_queue
+  __ mov(RunMicrotasksDescriptor::MicrotaskQueueRegister(), a1);
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void GetSharedFunctionInfoBytecode(MacroAssembler* masm,
                                           Register sfi_data,
                                           Register scratch1) {

src/builtins/mips64/builtins-mips64.cc

@@ -557,12 +557,16 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
 
     // TODO(plind): unify the ABI description here.
     // Registers:
-    // a0: root register value
-    // a1: entry address
-    // a2: function
-    // a3: receiver
-    // a4: argc
-    // a5: argv
+    //  either
+    //   a0: root register value
+    //   a1: entry address
+    //   a2: function
+    //   a3: receiver
+    //   a4: argc
+    //   a5: argv
+    //  or
+    //   a0: root register value
+    //   a1: microtask_queue
     //
     // Stack:
     // 0 arg slots on mips64 (4 args slots on mips)
@@ -599,11 +603,14 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
   __ daddiu(fp, sp, -EntryFrameConstants::kCallerFPOffset);
 
   // Registers:
-  // a1: entry_address
-  // a2: function
-  // a3: receiver_pointer
-  // a4: argc
-  // a5: argv
+  //  either
+  //   a1: entry address
+  //   a2: function
+  //   a3: receiver
+  //   a4: argc
+  //   a5: argv
+  //  or
+  //   a1: microtask_queue
   //
   // Stack:
   // caller fp          |
@@ -660,11 +667,16 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
   // saved values before returning a failure to C.
   //
   // Registers:
-  // a1: entry_address
-  // a2: function
-  // a3: receiver_pointer
-  // a4: argc
-  // a5: argv
+  //  either
+  //   a0: root register value
+  //   a1: entry address
+  //   a2: function
+  //   a3: receiver
+  //   a4: argc
+  //   a5: argv
+  //  or
+  //   a0: root register value
+  //   a1: microtask_queue
   //
   // Stack:
   // handler frame
@@ -724,7 +736,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
@@ -815,6 +828,12 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // a1: microtask_queue
+  __ mov(RunMicrotasksDescriptor::MicrotaskQueueRegister(), a1);
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void ReplaceClosureCodeWithOptimizedCode(
     MacroAssembler* masm, Register optimized_code, Register closure,
     Register scratch1, Register scratch2, Register scratch3) {

src/builtins/ppc/builtins-ppc.cc

@@ -720,7 +720,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 // Clobbers scratch1 and scratch2; preserves all other registers.
@@ -841,6 +842,12 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // r4: microtask_queue
+  __ mr(RunMicrotasksDescriptor::MicrotaskQueueRegister(), r4);
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void ReplaceClosureCodeWithOptimizedCode(
     MacroAssembler* masm, Register optimized_code, Register closure,
     Register scratch1, Register scratch2, Register scratch3) {

src/builtins/s390/builtins-s390.cc

@@ -756,7 +756,8 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 // Clobbers scratch1 and scratch2; preserves all other registers.
@@ -891,6 +892,12 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // r3: microtask_queue
+  __ mov(RunMicrotasksDescriptor::MicrotaskQueueRegister(), Operand(r3));
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void ReplaceClosureCodeWithOptimizedCode(
     MacroAssembler* masm, Register optimized_code, Register closure,
     Register scratch1, Register scratch2, Register scratch3) {

src/builtins/x64/builtins-x64.cc

@@ -365,11 +365,13 @@ void Builtins::Generate_ConstructedNonConstructable(MacroAssembler* masm) {
 namespace {
 
 // Called with the native C calling convention. The corresponding function
-// signature is:
-//
-//  using JSEntryFunction = GeneratedCode<Address(
-//      Address root_register_value, Address new_target, Address target,
-//      Address receiver, intptr_t argc, Address** args)>;
+// signature is either:
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, Address new_target, Address target,
+//       Address receiver, intptr_t argc, Address** argv)>;
+// or
+//   using JSEntryFunction = GeneratedCode<Address(
+//       Address root_register_value, MicrotaskQueue* microtask_queue)>;
 void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
                              Builtins::Name entry_trampoline) {
   Label invoke, handler_entry, exit;
@@ -542,12 +544,13 @@ void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) {
 }
 
 void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) {
-  Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasks);
+  Generate_JSEntryVariant(masm, StackFrame::ENTRY,
+                          Builtins::kRunMicrotasksTrampoline);
 }
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
                                              bool is_construct) {
-  // Expects five C++ function parameters.
+  // Expects six C++ function parameters.
   // - Address root_register_value
   // - Address new_target (tagged Object pointer)
   // - Address function (tagged JSFunction pointer)
@@ -672,6 +675,12 @@ void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
+void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) {
+  // arg_reg_2: microtask_queue
+  __ movp(RunMicrotasksDescriptor::MicrotaskQueueRegister(), arg_reg_2);
+  __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET);
+}
+
 static void GetSharedFunctionInfoBytecode(MacroAssembler* masm,
                                           Register sfi_data,
                                           Register scratch1) {

src/execution.cc

@@ -269,29 +269,46 @@ V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
     // allocation of handles without explicit handle scopes.
     SaveContext save(isolate);
     SealHandleScope shs(isolate);
-    // clang-format off
-    // {new_target}, {target}, {receiver}, return value: tagged pointers
-    // {argv}: pointer to array of tagged pointers
-    using JSEntryFunction = GeneratedCode<Address(
-        Address root_register_value, Address new_target, Address target,
-        Address receiver, intptr_t argc, Address** argv)>;
-    // clang-format on
-    JSEntryFunction stub_entry =
-        JSEntryFunction::FromAddress(isolate, code->InstructionStart());
 
     if (FLAG_clear_exceptions_on_js_entry) isolate->clear_pending_exception();
 
-    // Call the function through the right JS entry stub.
-    Address orig_func = params.new_target->ptr();
-    Address func = params.target->ptr();
-    Address recv = params.receiver->ptr();
-    Address** argv = reinterpret_cast<Address**>(params.argv);
-    if (FLAG_profile_deserialization && params.target->IsJSFunction()) {
-      PrintDeserializedCodeInfo(Handle<JSFunction>::cast(params.target));
+    if (params.execution_target == Execution::Target::kCallable) {
+      // clang-format off
+      // {new_target}, {target}, {receiver}, return value: tagged pointers
+      // {argv}: pointer to array of tagged pointers
+      using JSEntryFunction = GeneratedCode<Address(
+          Address root_register_value, Address new_target, Address target,
+          Address receiver, intptr_t argc, Address** argv)>;
+      // clang-format on
+      JSEntryFunction stub_entry =
+          JSEntryFunction::FromAddress(isolate, code->InstructionStart());
+
+      Address orig_func = params.new_target->ptr();
+      Address func = params.target->ptr();
+      Address recv = params.receiver->ptr();
+      Address** argv = reinterpret_cast<Address**>(params.argv);
+      if (FLAG_profile_deserialization && params.target->IsJSFunction()) {
+        PrintDeserializedCodeInfo(Handle<JSFunction>::cast(params.target));
+      }
+      RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kJS_Execution);
+      value = Object(stub_entry.Call(isolate->isolate_data()->isolate_root(),
+                                     orig_func, func, recv, params.argc, argv));
+    } else {
+      DCHECK_EQ(Execution::Target::kRunMicrotasks, params.execution_target);
+
+      // clang-format off
+      // return value: tagged pointers
+      // {microtask_queue}: pointer to a C++ object
+      using JSEntryFunction = GeneratedCode<Address(
+          Address root_register_value, MicrotaskQueue* microtask_queue)>;
+      // clang-format on
+      JSEntryFunction stub_entry =
+          JSEntryFunction::FromAddress(isolate, code->InstructionStart());
+
+      RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kJS_Execution);
+      value = Object(stub_entry.Call(isolate->isolate_data()->isolate_root(),
+                                     params.microtask_queue));
     }
-    RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kJS_Execution);
-    value = Object(stub_entry.Call(isolate->isolate_data()->isolate_root(),
-                                   orig_func, func, recv, params.argc, argv));
   }
 
 #ifdef VERIFY_HEAP

src/ia32/frame-constants-ia32.h

@@ -17,12 +17,19 @@ class EntryFrameConstants : public AllStatic {
   // Isolate::c_entry_fp onto the stack.
   static constexpr int kCallerFPOffset = -6 * kPointerSize;
 
+  // EntryFrame is used by JSEntry, JSConstructEntry and JSRunMicrotasksEntry.
+  // All of them take |root_register_value| as the first parameter.
   static constexpr int kRootRegisterValueOffset = +2 * kPointerSize;
+
+  // Rest of parameters passed to JSEntry and JSConstructEntry.
   static constexpr int kNewTargetArgOffset = +3 * kPointerSize;
   static constexpr int kFunctionArgOffset = +4 * kPointerSize;
   static constexpr int kReceiverArgOffset = +5 * kPointerSize;
   static constexpr int kArgcOffset = +6 * kPointerSize;
   static constexpr int kArgvOffset = +7 * kPointerSize;
+
+  // Rest of parameters passed to JSRunMicrotasksEntry.
+  static constexpr int kMicrotaskQueueArgOffset = +3 * kPointerSize;
 };
 
 class ExitFrameConstants : public TypedFrameConstants {

src/interface-descriptors.cc

@@ -386,6 +386,17 @@ void CloneObjectWithVectorDescriptor::InitializePlatformSpecific(
   DefaultInitializePlatformSpecific(data, kParameterCount);
 }
 
+// static
+Register RunMicrotasksDescriptor::MicrotaskQueueRegister() {
+  return CallDescriptors::call_descriptor_data(CallDescriptors::RunMicrotasks)
+      ->register_param(0);
+}
+
+void RunMicrotasksDescriptor::InitializePlatformSpecific(
+    CallInterfaceDescriptorData* data) {
+  DefaultInitializePlatformSpecific(data, kParameterCount);
+}
+
 void BigIntToWasmI64Descriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   DefaultInitializePlatformSpecific(data, kParameterCount);

src/interface-descriptors.h

@@ -1107,8 +1107,11 @@ class FrameDropperTrampolineDescriptor final : public CallInterfaceDescriptor {
 
 class RunMicrotasksDescriptor final : public CallInterfaceDescriptor {
  public:
-  DEFINE_PARAMETERS()
-  DECLARE_DEFAULT_DESCRIPTOR(RunMicrotasksDescriptor, CallInterfaceDescriptor)
+  DEFINE_PARAMETERS(kMicrotaskQueue)
+  DEFINE_PARAMETER_TYPES(MachineType::Pointer())
+  DECLARE_DESCRIPTOR(RunMicrotasksDescriptor, CallInterfaceDescriptor)
+
+  static Register MicrotaskQueueRegister();
 };
 
 class WasmMemoryGrowDescriptor final : public CallInterfaceDescriptor {