Add WasmFrame, backtraces reflect wasm's presence

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 @@
   // Get the next stack handler in the chain.
   inline StackHandler* next() const;
 
   // Conversion support.
   static inline StackHandler* FromAddress(Address address);
 
  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(INTERPRETED, InterpretedFrame)                       \
   V(STUB, StubFrame)                                     \
   V(STUB_FAILURE_TRAMPOLINE, StubFailureTrampolineFrame) \
   V(INTERNAL, InternalFrame)                             \
   V(CONSTRUCT, ConstructFrame)                           \
   V(ARGUMENTS_ADAPTOR, ArgumentsAdaptorFrame)
 
 // Every pointer in a frame has a slot id. On 32-bit platforms, doubles consume
 // two slots.
 //
@@ skipping 186 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_arguments_adaptor() const { return type() == ARGUMENTS_ADAPTOR; }
   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);
   }
 
+  bool is_visible() const {
+    Type type = this->type();
+    return is_java_script() || (type == WASM);
+  }
+
   // 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 273 matching lines @@
   void Print();
 
  private:
   Handle<Object> receiver_;
   Handle<JSFunction> function_;
   Handle<AbstractCode> abstract_code_;
   int code_offset_;
   bool is_constructor_;
 };
 
+class VisibleFrame : public StandardFrame {
+ public:
+  // Build a list with summaries for this frame including all inlined frames.
+  virtual void Summarize(List<FrameSummary>* frames) = 0;
 
-class JavaScriptFrame: public StandardFrame {
+  static VisibleFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_visible());
+    return static_cast<VisibleFrame*>(frame);
+  }
+
+ protected:
+  inline explicit VisibleFrame(StackFrameIteratorBase* iterator);
+
+ private:
+  friend class StackFrameIteratorBase;
+};
+
+class JavaScriptFrame : public VisibleFrame {
  public:
   Type type() const override { return JAVA_SCRIPT; }
 
   // Accessors.
   inline JSFunction* function() const;
   inline Object* receiver() const;
   inline void set_receiver(Object* value);
 
   // Access the parameters.
   inline Address GetParameterSlot(int index) const;
@@ skipping 34 matching lines @@
   void Print(StringStream* accumulator, PrintMode mode,
              int index) const override;
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
 
   // Return a list with JSFunctions of this frame.
   virtual void GetFunctions(List<JSFunction*>* functions) const;
 
   // Build a list with summaries for this frame including all inlined frames.
-  virtual void Summarize(List<FrameSummary>* frames);
+  void Summarize(List<FrameSummary>* frames) override;
 
   // Lookup exception handler for current {pc}, returns -1 if none found. Also
   // returns data associated with the handler site specific to the frame type:
   //  - JavaScriptFrame : Data is the stack depth at entry of the try-block.
   //  - OptimizedFrame  : Data is the stack slot count of the entire frame.
   //  - InterpretedFrame: Data is the register index holding the context.
   virtual int LookupExceptionHandlerInTable(
       int* data, HandlerTable::CatchPrediction* prediction);
 
   // Architecture-specific register description.
@@ skipping 147 matching lines @@
   inline explicit ArgumentsAdaptorFrame(StackFrameIteratorBase* iterator);
 
   int GetNumberOfIncomingArguments() const override;
 
   Address GetCallerStackPointer() const override;
 
  private:
   friend class StackFrameIteratorBase;
 };
 
+class WasmFrame : public VisibleFrame {
+ 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;
+
+  void Summarize(List<FrameSummary>* frames) override;
+
+ protected:
+  inline explicit WasmFrame(StackFrameIteratorBase* iterator);
+
+  Address GetCallerStackPointer() const override;
+
+ private:
+  friend class StackFrameIteratorBase;
+};
 
 class InternalFrame: public StandardFrame {
  public:
   Type type() const override { return INTERNAL; }
 
   // Garbage collection support.
   void Iterate(ObjectVisitor* v) const override;
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
@@ skipping 113 matching lines @@
   }
   void Advance();
 
  private:
   // Go back to the first frame.
   void Reset(ThreadLocalTop* top);
 
   DISALLOW_COPY_AND_ASSIGN(StackFrameIterator);
 };
 
+// Iterator that supports iterating through all Visible frames.
+class VisibleFrameIterator BASE_EMBEDDED {
+ public:
+  inline explicit VisibleFrameIterator(Isolate* isolate);
+
+  inline VisibleFrame* frame() const;
+
+  bool done() const { return iterator_.done(); }
+  void Advance();
+
+ protected:
+  struct NoAdvance {};  // Sentinel: construct iterator_, but don't advance it.
+  inline VisibleFrameIterator(Isolate* isolate, NoAdvance);
+  inline VisibleFrameIterator(Isolate* isolate, ThreadLocalTop* top, NoAdvance);
+  StackFrameIterator iterator_;
+};
 
 // Iterator that supports iterating through all JavaScript frames.
-class JavaScriptFrameIterator BASE_EMBEDDED {
+class JavaScriptFrameIterator : public VisibleFrameIterator {
  public:
   inline explicit JavaScriptFrameIterator(Isolate* isolate);
   inline JavaScriptFrameIterator(Isolate* isolate, ThreadLocalTop* top);
   // Skip frames until the frame with the given id is reached.
   JavaScriptFrameIterator(Isolate* isolate, StackFrame::Id id);
 
   inline JavaScriptFrame* frame() const;
 
-  bool done() const { return iterator_.done(); }
   void Advance();
 
   // Advance to the frame holding the arguments for the current
   // frame. This only affects the current frame if it has adapted
   // arguments.
   void AdvanceToArgumentsFrame();
-
- private:
-  StackFrameIterator iterator_;
 };
 
 
 // NOTE: The stack trace frame iterator is an iterator that only
 // traverse proper JavaScript frames; that is JavaScript frames that
 // have proper JavaScript functions. This excludes the problematic
 // functions in runtime.js.
 class StackTraceFrameIterator: public JavaScriptFrameIterator {
  public:
   explicit StackTraceFrameIterator(Isolate* isolate);
@@ skipping 47 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_