Add WasmFrame, backtraces reflect wasm's presence

src/frames-inl.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_INL_H_
 #define V8_FRAMES_INL_H_
 
 #include "src/frames.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 133 matching lines @@
   return marker == Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR);
 }
 
 
 inline bool StandardFrame::IsConstructFrame(Address fp) {
   Object* marker =
       Memory::Object_at(fp + StandardFrameConstants::kMarkerOffset);
   return marker == Smi::FromInt(StackFrame::CONSTRUCT);
 }
 
+inline VisibleFrame::VisibleFrame(StackFrameIteratorBase* iterator)
+    : StandardFrame(iterator) {}
 
 inline JavaScriptFrame::JavaScriptFrame(StackFrameIteratorBase* iterator)
-    : StandardFrame(iterator) {
-}
-
+    : VisibleFrame(iterator) {}
 
 Address JavaScriptFrame::GetParameterSlot(int index) const {
   int param_count = ComputeParametersCount();
   DCHECK(-1 <= index && index < param_count);
   int parameter_offset = (param_count - index - 1) * kPointerSize;
   return caller_sp() + parameter_offset;
 }
 
 
 Object* JavaScriptFrame::GetParameter(int index) const {
@@ skipping 66 matching lines @@
 
 
 inline InterpretedFrame::InterpretedFrame(StackFrameIteratorBase* iterator)
     : JavaScriptFrame(iterator) {}
 
 
 inline ArgumentsAdaptorFrame::ArgumentsAdaptorFrame(
     StackFrameIteratorBase* iterator) : JavaScriptFrame(iterator) {
 }
 
+inline WasmFrame::WasmFrame(StackFrameIteratorBase* iterator)
+    : VisibleFrame(iterator) {}
 
 inline InternalFrame::InternalFrame(StackFrameIteratorBase* iterator)
     : StandardFrame(iterator) {
 }
 
 
 inline StubFailureTrampolineFrame::StubFailureTrampolineFrame(
     StackFrameIteratorBase* iterator) : StandardFrame(iterator) {
 }
 
 
 inline ConstructFrame::ConstructFrame(StackFrameIteratorBase* iterator)
     : InternalFrame(iterator) {
 }
 
-
-inline JavaScriptFrameIterator::JavaScriptFrameIterator(
-    Isolate* isolate)
+inline VisibleFrameIterator::VisibleFrameIterator(Isolate* isolate)
     : iterator_(isolate) {
   if (!done()) Advance();
 }
 
+inline VisibleFrameIterator::VisibleFrameIterator(
+    Isolate* isolate, VisibleFrameIterator::NoAdvance)
+    : iterator_(isolate) {}
 
-inline JavaScriptFrameIterator::JavaScriptFrameIterator(
-    Isolate* isolate, ThreadLocalTop* top)
-    : iterator_(isolate, top) {
+inline VisibleFrameIterator::VisibleFrameIterator(
+    Isolate* isolate, ThreadLocalTop* top, VisibleFrameIterator::NoAdvance)
+    : iterator_(isolate, top) {}
+
+inline JavaScriptFrameIterator::JavaScriptFrameIterator(Isolate* isolate)
+    : VisibleFrameIterator(isolate, VisibleFrameIterator::NoAdvance()) {
   if (!done()) Advance();
 }
 
+inline JavaScriptFrameIterator::JavaScriptFrameIterator(Isolate* isolate,
+                                                        ThreadLocalTop* top)
+    : VisibleFrameIterator(isolate, top, VisibleFrameIterator::NoAdvance()) {
+  if (!done()) Advance();
+}
 
-inline JavaScriptFrame* JavaScriptFrameIterator::frame() const {
+inline VisibleFrame* VisibleFrameIterator::frame() const {
   // TODO(1233797): The frame hierarchy needs to change. It's
   // problematic that we can't use the safe-cast operator to cast to
   // the JavaScript frame type, because we may encounter arguments
   // adaptor frames.
   StackFrame* frame = iterator_.frame();
+  DCHECK(frame->is_visible() || frame->is_arguments_adaptor());
+  return static_cast<VisibleFrame*>(frame);
+}
+
+inline JavaScriptFrame* JavaScriptFrameIterator::frame() const {
+  StackFrame* frame = iterator_.frame();
   DCHECK(frame->is_java_script() || frame->is_arguments_adaptor());
   return static_cast<JavaScriptFrame*>(frame);
 }
 
 
 inline StackFrame* SafeStackFrameIterator::frame() const {
   DCHECK(!done());
   DCHECK(frame_->is_java_script() || frame_->is_exit());
   return frame_;
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_FRAMES_INL_H_