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

src/frames.h

 // 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.
 
 #ifndef V8_FRAMES_H_
 #define V8_FRAMES_H_
 
 #include "src/allocation.h"
 #include "src/handles.h"
 #include "src/safepoint-table.h"
@@ skipping 94 matching lines @@
   V(OPTIMIZED, OptimizedFrame)                           \
   V(WASM, WasmFrame)                                     \
   V(WASM_TO_JS, WasmToJsFrame)                           \
   V(JS_TO_WASM, JsToWasmFrame)                           \
   V(INTERPRETED, InterpretedFrame)                       \
   V(STUB, StubFrame)                                     \
   V(STUB_FAILURE_TRAMPOLINE, StubFailureTrampolineFrame) \
   V(INTERNAL, InternalFrame)                             \
   V(CONSTRUCT, ConstructFrame)                           \
   V(ARGUMENTS_ADAPTOR, ArgumentsAdaptorFrame)            \
-  V(BUILTIN, BuiltinFrame)
+  V(BUILTIN, BuiltinFrame)                               \
+  V(BUILTIN_EXIT, BuiltinExitFrame)
 
 // Every pointer in a frame has a slot id. On 32-bit platforms, doubles consume
 // two slots.
 //
 // Stack slot indices >= 0 access the callee stack with slot 0 corresponding to
 // the callee's saved return address and 1 corresponding to the saved frame
 // pointer. Some frames have additional information stored in the fixed header,
 // for example JSFunctions store the function context and marker in the fixed
 // header, with slot index 2 corresponding to the current function context and 3
 // corresponding to the frame marker/JSFunction.
@@ skipping 190 matching lines @@
 class StubFailureTrampolineFrameConstants : public InternalFrameConstants {
  public:
   static const int kArgumentsArgumentsOffset =
       TYPED_FRAME_PUSHED_VALUE_OFFSET(0);
   static const int kArgumentsLengthOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(1);
   static const int kArgumentsPointerOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(2);
   static const int kFixedHeaderBottomOffset = kArgumentsPointerOffset;
   DEFINE_TYPED_FRAME_SIZES(3);
 };
 
+// Behaves like an exit frame but with target and new target args.
+class BuiltinExitFrameConstants : public CommonFrameConstants {
+ public:
+  static const int kNewTargetOffset = kCallerPCOffset + 1 * kPointerSize;
+  static const int kTargetOffset = kNewTargetOffset + 1 * kPointerSize;
+};
 
 class InterpreterFrameConstants : public AllStatic {
  public:
   // Fixed frame includes new.target and bytecode offset.
   static const int kFixedFrameSize =
       StandardFrameConstants::kFixedFrameSize + 3 * kPointerSize;
   static const int kFixedFrameSizeFromFp =
       StandardFrameConstants::kFixedFrameSizeFromFp + 3 * kPointerSize;
 
   // FP-relative.
@@ skipping 83 matching lines @@
   bool is_wasm() const { return type() == WASM; }
   bool is_wasm_to_js() const { return type() == WASM_TO_JS; }
   bool is_js_to_wasm() const { return type() == JS_TO_WASM; }
   bool is_arguments_adaptor() const { return type() == ARGUMENTS_ADAPTOR; }
   bool is_builtin() const { return type() == BUILTIN; }
   bool is_internal() const { return type() == INTERNAL; }
   bool is_stub_failure_trampoline() const {
     return type() == STUB_FAILURE_TRAMPOLINE;
   }
   bool is_construct() const { return type() == CONSTRUCT; }
+  bool is_builtin_exit() const { return type() == BUILTIN_EXIT; }
   virtual bool is_standard() const { return false; }
 
   bool is_java_script() const {
     Type type = this->type();
     return (type == JAVA_SCRIPT) || (type == OPTIMIZED) ||
            (type == INTERPRETED) || (type == BUILTIN);
   }
 
   // Accessors.
   Address sp() const { return state_.sp; }
@@ skipping 184 matching lines @@
   static ExitFrame* cast(StackFrame* frame) {
     DCHECK(frame->is_exit());
     return static_cast<ExitFrame*>(frame);
   }
 
   // Compute the state and type of an exit frame given a frame
   // pointer. Used when constructing the first stack frame seen by an
   // iterator and the frames following entry frames.
   static Type GetStateForFramePointer(Address fp, State* state);
   static Address ComputeStackPointer(Address fp);
+  static StackFrame::Type ComputeFrameType(Address fp);
   static void FillState(Address fp, Address sp, State* state);
 
  protected:
   inline explicit ExitFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
  private:
   void ComputeCallerState(State* state) const override;
 
   friend class StackFrameIteratorBase;
 };
 
+// Builtin exit frames are a special case of exit frames, which are used
+// whenever C++ builtins (e.g., Math.acos) are called. Their main purpose is
+// to allow such builtins to appear in stack traces.
+class BuiltinExitFrame : public ExitFrame {
+ public:
+  Type type() const override { return BUILTIN_EXIT; }
+
+  static BuiltinExitFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_builtin_exit());
+    return static_cast<BuiltinExitFrame*>(frame);
+  }
+
+  virtual JSFunction* function() const;
+
+ protected:
+  inline explicit BuiltinExitFrame(StackFrameIteratorBase* iterator);
+
+ private:
+  inline Object* function_slot_object() const;
+
+  friend class StackFrameIteratorBase;
+};
+
 class JavaScriptFrame;
 
 class FrameSummary BASE_EMBEDDED {
  public:
   // Mode for JavaScriptFrame::Summarize. Exact summary is required to produce
   // an exact stack trace. It will trigger an assertion failure if that is not
   // possible, e.g., because of missing deoptimization information. The
   // approximate mode should produce a summary even without deoptimization
   // information, but it might miss frames.
   enum Mode { kExactSummary, kApproximateSummary };
@@ skipping 595 matching lines @@
 
 
 // Reads all frames on the current stack and copies them into the current
 // zone memory.
 Vector<StackFrame*> CreateStackMap(Isolate* isolate, Zone* zone);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_FRAMES_H_