[sparkplug] Use EnterFrame/LeaveFrame with StackFrame::BASELINE

Using StackFrame::MANUAL was a bit of a hack to avoid frame markers to
be pushed, but manual in FrameScope means Enter/LeaveFrame aren't
called at all.  This decouples those things.

Bug: v8:11429
Change-Id: Ie1603bb3c6858f0b97a75e4bb0b9bd1244de6cce
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2707205
Commit-Queue: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Cr-Commit-Position: refs/heads/master@{#72909}

src/baseline/arm64/baseline-compiler-arm64-inl.h

@@ -481,7 +481,7 @@ void BaselineCompiler::Prologue() {
   __ masm()->Mov(kInterpreterBytecodeArrayRegister, Operand(bytecode_));
   DCHECK_EQ(kJSFunctionRegister, kJavaScriptCallTargetRegister);
   // Enter the frame here, since CallBuiltin will override lr.
-  __ masm()->EnterFrame(StackFrame::MANUAL);
+  __ masm()->EnterFrame(StackFrame::BASELINE);
   CallBuiltin(Builtins::kBaselineOutOfLinePrologue, kContextRegister,
               kJSFunctionRegister, kJavaScriptCallArgCountRegister,
               kInterpreterBytecodeArrayRegister);
@@ -617,7 +617,7 @@ void BaselineAssembler::EmitReturn(MacroAssembler* masm) {
   __ Bind(&corrected_args_count);
 
   // Leave the frame (also dropping the register file).
-  __ masm()->LeaveFrame(StackFrame::MANUAL);
+  __ masm()->LeaveFrame(StackFrame::BASELINE);
 
   // Drop receiver + arguments.
   __ masm()->Add(params_size, params_size, 1);  // Include the receiver.

src/baseline/x64/baseline-compiler-x64-inl.h

@@ -485,7 +485,7 @@ void BaselineAssembler::EmitReturn(MacroAssembler* masm) {
   __ Bind(&corrected_args_count);
 
   // Leave the frame (also dropping the register file).
-  __ masm()->LeaveFrame(StackFrame::MANUAL);
+  __ masm()->LeaveFrame(StackFrame::BASELINE);
 
   // Drop receiver + arguments.
   Register return_pc = scratch;

src/builtins/x64/builtins-x64.cc

@@ -1651,7 +1651,7 @@ void Builtins::Generate_BaselineOutOfLinePrologue(MacroAssembler* masm) {
   // set-up frame once we're done setting it up.
   __ PopReturnAddressTo(return_address);
   FrameScope frame_scope(masm, StackFrame::MANUAL);
-  __ EnterFrame(StackFrame::MANUAL);
+  __ EnterFrame(StackFrame::BASELINE);
 
   __ Push(descriptor.GetRegisterParameter(
       BaselineOutOfLinePrologueDescriptor::kCalleeContext));  // Callee's

src/codegen/arm64/macro-assembler-arm64.cc

@@ -2497,7 +2497,7 @@ void TurboAssembler::EnterFrame(StackFrame::Type type) {
     // sp[1] : type
     // sp[0] : cp
   } else {
-    DCHECK_EQ(type, StackFrame::MANUAL);
+    DCHECK(StackFrame::IsJavaScript(type));
     // Just push a minimal "machine frame", saving the frame pointer and return
     // address, without any markers.
     Push<TurboAssembler::kSignLR>(lr, fp);

src/codegen/x64/macro-assembler-x64.cc

@@ -3228,7 +3228,7 @@ void TurboAssembler::Prologue() {
 void TurboAssembler::EnterFrame(StackFrame::Type type) {
   pushq(rbp);
   movq(rbp, rsp);
-  if (type != StackFrame::MANUAL) {
+  if (!StackFrame::IsJavaScript(type)) {
     Push(Immediate(StackFrame::TypeToMarker(type)));
   }
 }
@@ -3237,7 +3237,7 @@ void TurboAssembler::LeaveFrame(StackFrame::Type type) {
   // TODO(v8:11429): Consider passing BASELINE instead, and checking for
   // IsJSFrame or similar. Could then unify with manual frame leaves in the
   // interpreter too.
-  if (emit_debug_code() && type != StackFrame::MANUAL) {
+  if (emit_debug_code() && !StackFrame::IsJavaScript(type)) {
     cmpq(Operand(rbp, CommonFrameConstants::kContextOrFrameTypeOffset),
          Immediate(StackFrame::TypeToMarker(type)));
     Check(equal, AbortReason::kStackFrameTypesMustMatch);

src/execution/frames.h

@@ -233,12 +233,12 @@ class StackFrame {
   bool is_construct() const { return type() == CONSTRUCT; }
   bool is_builtin_exit() const { return type() == BUILTIN_EXIT; }
 
-  bool is_java_script() const {
+  static bool IsJavaScript(Type t) {
     STATIC_ASSERT(INTERPRETED + 1 == BASELINE);
     STATIC_ASSERT(BASELINE + 1 == OPTIMIZED);
-    Type t = type();
     return t >= INTERPRETED && t <= OPTIMIZED;
   }
+  bool is_java_script() const { return IsJavaScript(type()); }
   bool is_wasm_to_js() const { return type() == WASM_TO_JS; }
   bool is_js_to_wasm() const { return type() == JS_TO_WASM; }