Revert of [builtins] New frame type for exits to C++ builtins

src/frames.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/frames.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/ast/scopeinfo.h"
@@ skipping 307 matching lines @@
            external_callback_scope_->scope_address() < frame_->fp()) {
       // As long as the setup of a frame is not atomic, we may happen to be
       // in an interval where an ExternalCallbackScope is already created,
       // but the frame is not yet entered. So we are actually observing
       // the previous frame.
       // Skip all the ExternalCallbackScope's that are below the current fp.
       last_callback_scope = external_callback_scope_;
       external_callback_scope_ = external_callback_scope_->previous();
     }
     if (frame_->is_java_script()) break;
-    if (frame_->is_exit() || frame_->is_builtin_exit()) {
+    if (frame_->is_exit()) {
       // Some of the EXIT frames may have ExternalCallbackScope allocated on
       // top of them. In that case the scope corresponds to the first EXIT
       // frame beneath it. There may be other EXIT frames on top of the
       // ExternalCallbackScope, just skip them as we cannot collect any useful
       // information about them.
       if (last_callback_scope) {
         frame_->state_.pc_address =
             last_callback_scope->callback_entrypoint_address();
       }
       break;
@@ skipping 139 matching lines @@
     }
   }
 
   DCHECK(marker->IsSmi());
   StackFrame::Type candidate =
       static_cast<StackFrame::Type>(Smi::cast(marker)->value());
   switch (candidate) {
     case ENTRY:
     case ENTRY_CONSTRUCT:
     case EXIT:
-    case BUILTIN_EXIT:
     case STUB:
     case STUB_FAILURE_TRAMPOLINE:
     case INTERNAL:
     case CONSTRUCT:
     case ARGUMENTS_ADAPTOR:
     case WASM_TO_JS:
     case WASM:
       return candidate;
     case JS_TO_WASM:
     case JAVA_SCRIPT:
@@ skipping 53 matching lines @@
 Code* EntryConstructFrame::unchecked_code() const {
   return isolate()->heap()->js_construct_entry_code();
 }
 
 
 Object*& ExitFrame::code_slot() const {
   const int offset = ExitFrameConstants::kCodeOffset;
   return Memory::Object_at(fp() + offset);
 }
 
+
 Code* ExitFrame::unchecked_code() const {
   return reinterpret_cast<Code*>(code_slot());
 }
 
 
 void ExitFrame::ComputeCallerState(State* state) const {
   // Set up the caller state.
   state->sp = caller_sp();
   state->fp = Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset);
   state->pc_address = ResolveReturnAddressLocation(
@@ skipping 21 matching lines @@
 Address ExitFrame::GetCallerStackPointer() const {
   return fp() + ExitFrameConstants::kCallerSPOffset;
 }
 
 
 StackFrame::Type ExitFrame::GetStateForFramePointer(Address fp, State* state) {
   if (fp == 0) return NONE;
   Address sp = ComputeStackPointer(fp);
   FillState(fp, sp, state);
   DCHECK(*state->pc_address != NULL);
-
-  return ComputeFrameType(fp);
-}
-
-StackFrame::Type ExitFrame::ComputeFrameType(Address fp) {
-  // Distinguish between between regular and builtin exit frames.
-  // Default to EXIT in all hairy cases (e.g., when called from profiler).
-  const int offset = ExitFrameConstants::kFrameTypeOffset;
-  Object* marker = Memory::Object_at(fp + offset);
-
-  if (!marker->IsSmi()) {
-    return EXIT;
-  }
-
-  StackFrame::Type frame_type =
-      static_cast<StackFrame::Type>(Smi::cast(marker)->value());
-  if (frame_type == EXIT || frame_type == BUILTIN_EXIT) {
-    return frame_type;
-  }
-
   return EXIT;
 }
 
 Address ExitFrame::ComputeStackPointer(Address fp) {
   MSAN_MEMORY_IS_INITIALIZED(fp + ExitFrameConstants::kSPOffset, kPointerSize);
   return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
 }
 
 void ExitFrame::FillState(Address fp, Address sp, State* state) {
   state->sp = sp;
   state->fp = fp;
   state->pc_address = ResolveReturnAddressLocation(
       reinterpret_cast<Address*>(sp - 1 * kPCOnStackSize));
   // The constant pool recorded in the exit frame is not associated
   // with the pc in this state (the return address into a C entry
   // stub).  ComputeCallerState will retrieve the constant pool
   // together with the associated caller pc.
   state->constant_pool_address = NULL;
 }
 
-JSFunction* BuiltinExitFrame::function() const {
-  return JSFunction::cast(function_slot_object());
-}
-
 Address StandardFrame::GetExpressionAddress(int n) const {
   const int offset = StandardFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
 Address InterpretedFrame::GetExpressionAddress(int n) const {
   const int offset = InterpreterFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
@@ skipping 38 matching lines @@
   int frame_header_size = StandardFrameConstants::kFixedFrameSizeFromFp;
   Object* marker =
       Memory::Object_at(fp() + CommonFrameConstants::kContextOrFrameTypeOffset);
   if (marker->IsSmi()) {
     StackFrame::Type candidate =
         static_cast<StackFrame::Type>(Smi::cast(marker)->value());
     switch (candidate) {
       case ENTRY:
       case ENTRY_CONSTRUCT:
       case EXIT:
-      case BUILTIN_EXIT:
       case STUB_FAILURE_TRAMPOLINE:
       case ARGUMENTS_ADAPTOR:
       case STUB:
       case INTERNAL:
       case CONSTRUCT:
       case JS_TO_WASM:
       case WASM_TO_JS:
       case WASM:
         frame_header_size = TypedFrameConstants::kFixedFrameSizeFromFp;
         break;
@@ skipping 1100 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8