[interpreter] First implementation of stack unwinding.

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 165 matching lines @@
 
 class InterpreterFrameConstants : public AllStatic {
  public:
   // Fixed frame includes new.target and bytecode offset.
   static const int kFixedFrameSize =
       StandardFrameConstants::kFixedFrameSize + 2 * kPointerSize;
   static const int kFixedFrameSizeFromFp =
       StandardFrameConstants::kFixedFrameSizeFromFp + 2 * kPointerSize;
 
   // FP-relative.
+  static const int kBytecodeOffsetFromFp =
+      -StandardFrameConstants::kFixedFrameSizeFromFp - 2 * kPointerSize;
   static const int kRegisterFilePointerFromFp =
       -StandardFrameConstants::kFixedFrameSizeFromFp - 3 * kPointerSize;
 
   // Register file pointer relative.
   static const int kLastParamFromRegisterPointer =
       StandardFrameConstants::kFixedFrameSize + 3 * kPointerSize;
 
   static const int kBytecodeOffsetFromRegisterPointer = 1 * kPointerSize;
   static const int kNewTargetFromRegisterPointer = 2 * kPointerSize;
   static const int kFunctionFromRegisterPointer = 3 * kPointerSize;
@@ skipping 46 matching lines @@
     this->state_ = original.state_;
     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_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();
@@ skipping 442 matching lines @@
   inline explicit OptimizedFrame(StackFrameIteratorBase* iterator);
 
  private:
   friend class StackFrameIteratorBase;
 
   Object* StackSlotAt(int index) const;
 };
 
 
 class InterpretedFrame : public JavaScriptFrame {
+ public:
   Type type() const override { return INTERPRETED; }
 
+  // Lookup exception handler for current {pc}, returns -1 if none found. Also
+  // returns the expected number of stack slots at the handler site.
+  int LookupExceptionHandlerInTable(
+      int* stack_slots, HandlerTable::CatchPrediction* prediction) override;
+
+  // Returns the current offset into the bytecode stream.
+  int GetBytecodeOffset() const;
+
+  // Updates the current offset into the bytecode stream, mainly used for stack
+  // unwinding to continue execution at a different bytecode offset.
+  void PatchBytecodeOffset(int new_offset);
+
  protected:
   inline explicit InterpretedFrame(StackFrameIteratorBase* iterator);
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 
 // Arguments adaptor frames are automatically inserted below
 // JavaScript frames when the actual number of parameters does not
@@ skipping 239 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_