wasm: implemente WasmFrame::cast, fix inheritance

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 396 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() const {

[bradn, 2016/03/28 23:46:06]

Keeping the 3 sorts of wasm frames orthogonal seems clearer to me.

[JF, 2016/03/29 00:24:06]

I don't mind either way, but if we keep them separate then they probably
shouldn't inherit from WasmFrame. I'm simply mimicking what JavaScriptFrame does
with OptimizedFrame and InterpretedFrame deriving from JavaScriptFrame, and
is_java_script() returning true if it's one of those 3 types.

+    return type() == WASM || is_wasm_to_js() || is_js_to_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_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; }
 
@@ skipping 360 matching lines @@
   //  - InterpretedFrame: Data is the register index holding the context.
   virtual int LookupExceptionHandlerInTable(
       int* data, HandlerTable::CatchPrediction* prediction);
 
   // Architecture-specific register description.
   static Register fp_register();
   static Register context_register();
   static Register constant_pool_pointer_register();
 
   static JavaScriptFrame* cast(StackFrame* frame) {
     DCHECK(frame->is_java_script());

[JF, 2016/03/29 00:24:06]

Compare to this, which is also true for OptimizedFrame and InterpreterFrame.

     return static_cast<JavaScriptFrame*>(frame);
   }
 
   static void PrintFunctionAndOffset(JSFunction* function, Code* code,
                                      Address pc, FILE* file,
                                      bool print_line_number);
 
   static void PrintTop(Isolate* isolate, FILE* file, bool print_args,
                        bool print_line_number);
 
@@ skipping 145 matching lines @@
   // 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;
 
+  static WasmFrame* cast(StackFrame* frame) {
+    DCHECK(frame->is_wasm());

[bradn, 2016/03/28 23:46:06]

Why not preserve the existing categories and dcheck or of all 3 here?

+    return static_cast<WasmFrame*>(frame);
+  }
+
  protected:
   inline explicit WasmFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 class WasmToJsFrame : public WasmFrame {
@@ skipping 221 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_