[wasm] prototype for breakpoint support.

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 85 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(StackHandler);
 };
 
 #define STACK_FRAME_TYPE_LIST(V)                         \
   V(ENTRY, EntryFrame)                                   \
   V(ENTRY_CONSTRUCT, EntryConstructFrame)                \
   V(EXIT, ExitFrame)                                     \
   V(JAVA_SCRIPT, JavaScriptFrame)                        \
   V(OPTIMIZED, OptimizedFrame)                           \
-  V(WASM, WasmFrame)                                     \
+  V(WASM_COMPILED, WasmCompiledFrame)                    \
   V(WASM_TO_JS, WasmToJsFrame)                           \
   V(JS_TO_WASM, JsToWasmFrame)                           \
+  V(WASM_INTERPRETED, WasmInterpretedFrame)              \
   V(INTERPRETED, InterpretedFrame)                       \
   V(STUB, StubFrame)                                     \
   V(STUB_FAILURE_TRAMPOLINE, StubFailureTrampolineFrame) \
   V(INTERNAL, InternalFrame)                             \
   V(CONSTRUCT, ConstructFrame)                           \
   V(ARGUMENTS_ADAPTOR, ArgumentsAdaptorFrame)            \
   V(BUILTIN, BuiltinFrame)
 
 // Every pointer in a frame has a slot id. On 32-bit platforms, doubles consume
 // two slots.
@@ skipping 290 matching lines @@
     this->iterator_ = NULL;
     this->isolate_ = original.isolate_;
   }
 
   // Type testers.
   bool is_entry() const { return type() == ENTRY; }
   bool is_entry_construct() const { return type() == ENTRY_CONSTRUCT; }
   bool is_exit() const { return type() == EXIT; }
   bool is_optimized() const { return type() == OPTIMIZED; }
   bool is_interpreted() const { return type() == INTERPRETED; }
-  bool is_wasm() const { return type() == WASM; }
+  bool is_wasm_compiled() const { return type() == WASM_COMPILED; }
+  bool is_wasm_interpreted() const { return type() == WASM_INTERPRETED; }
   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; }
   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);
   }
+  bool is_wasm() const {
+    Type type = this->type();
+    return type == WASM_COMPILED || type == WASM_INTERPRETED;
+  }
 
   // Accessors.
   Address sp() const { return state_.sp; }
   Address fp() const { return state_.fp; }
   Address caller_sp() const { return GetCallerStackPointer(); }
 
   // If this frame is optimized and was dynamically aligned return its old
   // unaligned frame pointer.  When the frame is deoptimized its FP will shift
   // up one word and become unaligned.
   Address UnpaddedFP() const;
@@ skipping 190 matching lines @@
   inline explicit ExitFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
  private:
   void ComputeCallerState(State* state) const override;
 
   friend class StackFrameIteratorBase;
 };
 
-class JavaScriptFrame;
+class StandardFrame;
 
 class FrameSummary BASE_EMBEDDED {
  public:
-  // Mode for JavaScriptFrame::Summarize. Exact summary is required to produce
+  // Mode for StandardFrame::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 };
+  enum Flags { kNone = 0, kIsConstructor = 1 << 0, kIsWasm = 1 << 1 };
 
+  // Constructor for JavaScript frame summaries.
   FrameSummary(Object* receiver, JSFunction* function,
                AbstractCode* abstract_code, int code_offset,
                bool is_constructor, Mode mode = kExactSummary);
+  // Constructor for Wasm frame summaries.
+  FrameSummary(Object* wasm_object, int function_index,
+               AbstractCode* abstract_code, int code_offset,
+               Mode mode = kExactSummary);
 
-  static FrameSummary GetFirst(JavaScriptFrame* frame);
+  static FrameSummary GetFirst(StandardFrame* frame);
+  static FrameSummary GetLast(StandardFrame* frame);
 
-  Handle<Object> receiver() { return receiver_; }
-  Handle<JSFunction> function() { return function_; }
+  inline Handle<Object> receiver();
+  inline Handle<Object> wasm_object();
+  inline Handle<JSFunction> function();
+  Script* script();
+  inline int wasm_function_index();
   Handle<AbstractCode> abstract_code() { return abstract_code_; }
   int code_offset() { return code_offset_; }
-  bool is_constructor() { return is_constructor_; }
+  bool is_constructor() { return flags & kIsConstructor; }
+  inline bool is_subject_to_debugging();
+
+  bool is_wasm() { return flags & kIsWasm; }
+  bool is_javascript() { return !(flags & kIsWasm); }
 
   void Print();
 
  private:
   Handle<Object> receiver_;
-  Handle<JSFunction> function_;
+  Handle<Object> function_;
   Handle<AbstractCode> abstract_code_;
   int code_offset_;
-  bool is_constructor_;
+  Flags flags;
 };
 
 class StandardFrame : public StackFrame {
  public:
   // Testers.
   bool is_standard() const override { return true; }
 
   // Accessors.
   virtual Object* receiver() const;
   virtual Script* script() const;
   virtual Object* context() const;
+  virtual Object* debug_info(bool create) const;
 
   // Access the expressions in the stack frame including locals.
   inline Object* GetExpression(int index) const;
   inline void SetExpression(int index, Object* value);
   int ComputeExpressionsCount() const;
 
   // Access the parameters.
   virtual Object* GetParameter(int index) const;
   virtual int ComputeParametersCount() const;
 
   void SetCallerFp(Address caller_fp) override;
 
   // Check if this frame is a constructor frame invoked through 'new'.
   virtual bool IsConstructor() const;
 
+  // Build a list with summaries for this frame including all inlined frames.
+  virtual void Summarize(
+      List<FrameSummary>* frames,
+      FrameSummary::Mode mode = FrameSummary::kExactSummary) const;
+
   static StandardFrame* cast(StackFrame* frame) {
     DCHECK(frame->is_standard());
     return static_cast<StandardFrame*>(frame);
   }
 
  protected:
   inline explicit StandardFrame(StackFrameIteratorBase* iterator);
 
   void ComputeCallerState(State* state) const override;
 
@@ skipping 29 matching lines @@
 
  private:
   friend class StackFrame;
   friend class SafeStackFrameIterator;
 };
 
 class JavaScriptFrame : public StandardFrame {
  public:
   Type type() const override { return JAVA_SCRIPT; }
 
-  // Build a list with summaries for this frame including all inlined frames.
-  virtual void Summarize(
+  void Summarize(
       List<FrameSummary>* frames,
-      FrameSummary::Mode mode = FrameSummary::kExactSummary) const;
+      FrameSummary::Mode mode = FrameSummary::kExactSummary) const override;
 
   // Accessors.
   virtual JSFunction* function() const;
   Object* receiver() const override;
   Object* context() const override;
   Script* script() const override;
+  Object* debug_info(bool create) const override;
 
   inline void set_receiver(Object* value);
 
   // Access the parameters.
   inline Address GetParameterSlot(int index) const;
   Object* GetParameter(int index) const override;
   int ComputeParametersCount() const override;
 
   // Access the operand stack.
   inline Address GetOperandSlot(int index) const;
@@ skipping 219 matching lines @@
   inline explicit BuiltinFrame(StackFrameIteratorBase* iterator);
 
   int GetNumberOfIncomingArguments() const final;
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 class WasmFrame : public StandardFrame {
  public:
-  Type type() const override { return WASM; }
-
   // GC support.
   void Iterate(ObjectVisitor* v) const override;
 
   // Printing support.
   void Print(StringStream* accumulator, PrintMode mode,
              int index) const override;
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
 
   // Accessors.
-  Object* wasm_obj() const;
-  uint32_t function_index() const;
-  Script* script() const override;
+  virtual Object* wasm_obj() const = 0;
 
   static WasmFrame* cast(StackFrame* frame) {
-    DCHECK(frame->is_wasm());
+    DCHECK(frame->is_wasm_compiled() || frame->is_wasm_interpreted());
     return static_cast<WasmFrame*>(frame);
   }
 
  protected:
   inline explicit WasmFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
  private:
   friend class StackFrameIteratorBase;
 };
 
+class WasmCompiledFrame : public WasmFrame {
+ public:
+  Type type() const override { return WASM_COMPILED; }
+
+  // Accessors.
+  Object* wasm_obj() const override;
+  uint32_t function_index() const;
+  Script* script() const override;
+  Object* debug_info(bool create) const override;
+
+  void Summarize(
+      List<FrameSummary>* frames,
+      FrameSummary::Mode mode = FrameSummary::kExactSummary) const override;
+
+  static WasmCompiledFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_wasm_compiled());
+    return static_cast<WasmCompiledFrame*>(frame);
+  }
+
+ protected:
+  inline explicit WasmCompiledFrame(StackFrameIteratorBase* iterator);
+
+ private:
+  friend class StackFrameIteratorBase;
+};
+
+class WasmInterpretedFrame : public WasmFrame {
+ public:
+  Type type() const override { return WASM_INTERPRETED; }
+
+  // Accessors.
+  Object* wasm_obj() const override;
+  // Return the debug info for the top-most interpreted function.
+  Object* debug_info(bool create) const override;
+
+  static WasmInterpretedFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_wasm_interpreted());
+    return static_cast<WasmInterpretedFrame*>(frame);
+  }
+
+  void Summarize(
+      List<FrameSummary>* frames,
+      FrameSummary::Mode mode = FrameSummary::kExactSummary) const override;
+
+ protected:
+  inline explicit WasmInterpretedFrame(StackFrameIteratorBase* iterator);
+
+ private:
+  friend class StackFrameIteratorBase;
+};
+
 class WasmToJsFrame : public StubFrame {
  public:
   Type type() const override { return WASM_TO_JS; }
 
  protected:
   inline explicit WasmToJsFrame(StackFrameIteratorBase* iterator);
 
  private:
   friend class StackFrameIteratorBase;
 };
@@ skipping 226 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_