[wasm] Introduce WasmToInterpreterFrame

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 79 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_INTERPRETER_ENTRY, WasmInterpreterEntryFrame)   \
   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_EXIT, BuiltinExitFrame)
 
 // Every pointer in a frame has a slot id. On 32-bit platforms, doubles consume
@@ skipping 343 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_to_js() const { return type() == WASM_TO_JS; }
   bool is_js_to_wasm() const { return type() == JS_TO_WASM; }
+  bool is_wasm_interpreter_entry() const {
+    return type() == WASM_INTERPRETER_ENTRY;
+  }
   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);
   }
+  bool is_wasm() const {
+    Type type = this->type();
+    return type == WASM_COMPILED || type == WASM_INTERPRETER_ENTRY;
+  }
 
   // Accessors.
   Address sp() const { return state_.sp; }
   Address fp() const { return state_.fp; }
   Address callee_pc() const {
     return state_.callee_pc_address ? *state_.callee_pc_address : nullptr;
   }
   Address caller_sp() const { return GetCallerStackPointer(); }
 
   // If this frame is optimized and was dynamically aligned return its old
@@ skipping 228 matching lines @@
   int ComputeParametersCount() const;
 
   inline Object* receiver_slot_object() const;
   inline Object* argc_slot_object() const;
   inline Object* target_slot_object() const;
   inline Object* new_target_slot_object() const;
 
   friend class StackFrameIteratorBase;
 };
 
-class JavaScriptFrame;
+class StandardFrame;
 
 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 };
 
   FrameSummary(Object* receiver, JSFunction* function,
                AbstractCode* abstract_code, int code_offset,
                bool is_constructor, Mode mode = kExactSummary);
 
-  static FrameSummary GetFirst(JavaScriptFrame* frame);
+  static FrameSummary GetFirst(StandardFrame* frame);
 
   Handle<Object> receiver() const { return receiver_; }
   Handle<JSFunction> function() const { return function_; }
   Handle<AbstractCode> abstract_code() const { return abstract_code_; }
   int code_offset() const { return code_offset_; }
   bool is_constructor() const { return is_constructor_; }
 
   void Print();
 
  private:
@@ skipping 22 matching lines @@
 
   // 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;
 
   inline void set_receiver(Object* value);
 
   // Access the parameters.
@@ skipping 231 matching lines @@
  protected:
   inline explicit BuiltinFrame(StackFrameIteratorBase* iterator);
 
   int GetNumberOfIncomingArguments() const final;
   void PrintFrameKind(StringStream* accumulator) const override;
 
  private:
   friend class StackFrameIteratorBase;
 };
 
-class WasmFrame : public StandardFrame {
+class WasmCompiledFrame : public StandardFrame {
  public:
-  Type type() const override { return WASM; }
+  Type type() const override { return WASM_COMPILED; }
 
   // GC support.
   void Iterate(ObjectVisitor* v) const override;
 
   // Printing support.
   void Print(StringStream* accumulator, PrintMode mode,
              int index) const override;
 
   // Lookup exception handler for current {pc}, returns -1 if none found. Also
   // returns the stack slot count of the entire frame.
   int LookupExceptionHandlerInTable(int* data);
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
 
   // Accessors.
   WasmInstanceObject* wasm_instance() const;
   uint32_t function_index() const;
   Script* script() const override;
   int position() const override;
   bool at_to_number_conversion() const;
 
-  static WasmFrame* cast(StackFrame* frame) {
-    DCHECK(frame->is_wasm());
-    return static_cast<WasmFrame*>(frame);
+  void Summarize(List<FrameSummary>* frames,
+                 FrameSummary::Mode mode) const override;
+
+  static WasmCompiledFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_wasm_compiled());
+    return static_cast<WasmCompiledFrame*>(frame);
   }
 
  protected:
-  inline explicit WasmFrame(StackFrameIteratorBase* iterator);
+  inline explicit WasmCompiledFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
+ private:
+  friend class StackFrameIteratorBase;
+};
+
+class WasmInterpreterEntryFrame : public StandardFrame {
+ public:
+  Type type() const override { return WASM_INTERPRETER_ENTRY; }
+
+  // GC support.
+  void Iterate(ObjectVisitor* v) const override;
+
+  // Printing support.
+  void Print(StringStream* accumulator, PrintMode mode,
+             int index) const override;
+
+  void Summarize(
+      List<FrameSummary>* frames,
+      FrameSummary::Mode mode = FrameSummary::kExactSummary) const override;
+
+  // Determine the code for the frame.
+  Code* unchecked_code() const override;
+
+  // Accessors.
+  WasmInstanceObject* wasm_instance() const;
+  Script* script() const override;
+  int position() const override;
+
+  static WasmInterpreterEntryFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_wasm_interpreter_entry());
+    return static_cast<WasmInterpreterEntryFrame*>(frame);
+  }
+
+ protected:
+  inline explicit WasmInterpreterEntryFrame(StackFrameIteratorBase* iterator);
+
+  Address GetCallerStackPointer() const override;
+
  private:
   friend class StackFrameIteratorBase;
 };
 
 class WasmToJsFrame : public StubFrame {
  public:
   Type type() const override { return WASM_TO_JS; }
 
  protected:
   inline explicit WasmToJsFrame(StackFrameIteratorBase* iterator);
@@ skipping 167 matching lines @@
   explicit StackTraceFrameIterator(Isolate* isolate);
   StackTraceFrameIterator(Isolate* isolate, StackFrame::Id id);
   bool done() const { return iterator_.done(); }
   void Advance();
 
   inline StandardFrame* frame() const;
 
   inline bool is_javascript() const;
   inline bool is_wasm() const;
   inline JavaScriptFrame* javascript_frame() const;
-  inline WasmFrame* wasm_frame() const;
+  // TODO(clemensh): Remove / refactor this for general wasm frames
+  // (compiled/interpreted).
+  inline WasmCompiledFrame* wasm_compiled_frame() const;
 
   // Advance to the frame holding the arguments for the current
   // frame. This only affects the current frame if it is a javascript frame and
   // has adapted arguments.
   void AdvanceToArgumentsFrame();
 
  private:
   StackFrameIterator iterator_;
   bool IsValidFrame(StackFrame* frame) const;
 };
@@ skipping 42 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_