[debugger] account for inlined functions when stepping.

src/debug/debug.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_DEBUG_DEBUG_H_
 #define V8_DEBUG_DEBUG_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/assembler.h"
@@ skipping 32 matching lines @@
   LastStepAction = StepIn
 };
 
 // Type of exception break. NOTE: These values are in macros.py as well.
 enum ExceptionBreakType {
   BreakException = 0,
   BreakUncaughtException = 1
 };
 
 
-// Type of exception break.
-enum BreakLocatorType { ALL_BREAK_LOCATIONS, CALLS_AND_RETURNS };
-
-
 // The different types of breakpoint position alignments.
 // Must match Debug.BreakPositionAlignment in debug.js
 enum BreakPositionAlignment {
   STATEMENT_ALIGNED = 0,
   BREAK_POSITION_ALIGNED = 1
 };
 
 enum DebugBreakType {
   NOT_DEBUG_BREAK,
   DEBUGGER_STATEMENT,
@@ skipping 48 matching lines @@
   DebugBreakType type_;
   int position_;
 
   friend class CodeBreakIterator;
   friend class BytecodeArrayBreakIterator;
 };
 
 class BreakIterator {
  public:
   static std::unique_ptr<BreakIterator> GetIterator(
-      Handle<DebugInfo> debug_info, Handle<AbstractCode> abstract_code,
-      BreakLocatorType type = ALL_BREAK_LOCATIONS);
+      Handle<DebugInfo> debug_info, Handle<AbstractCode> abstract_code);
 
   virtual ~BreakIterator() {}
 
   virtual BreakLocation GetBreakLocation() = 0;
   virtual bool Done() const = 0;
   virtual void Next() = 0;
 
   void SkipTo(int count) {
     while (count-- > 0) Next();
   }
 
   virtual int code_offset() = 0;
   int break_index() const { return break_index_; }
   inline int position() const { return position_; }
   inline int statement_position() const { return statement_position_; }
 
   virtual bool IsDebugBreak() = 0;
   virtual void ClearDebugBreak() = 0;
   virtual void SetDebugBreak() = 0;
 
  protected:
-  explicit BreakIterator(Handle<DebugInfo> debug_info,
-                         BreakLocatorType break_locator_type);
+  explicit BreakIterator(Handle<DebugInfo> debug_info);
 
   int BreakIndexFromPosition(int position, BreakPositionAlignment alignment);
 
   Isolate* isolate() { return debug_info_->GetIsolate(); }
 
   Handle<DebugInfo> debug_info_;
   int break_index_;
   int position_;
   int statement_position_;
-  BreakLocatorType break_locator_type_;
 
  private:
   DisallowHeapAllocation no_gc_;
   DISALLOW_COPY_AND_ASSIGN(BreakIterator);
 };
 
 class CodeBreakIterator : public BreakIterator {
  public:
-  CodeBreakIterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
+  explicit CodeBreakIterator(Handle<DebugInfo> debug_info);
   ~CodeBreakIterator() override {}
 
   BreakLocation GetBreakLocation() override;
   bool Done() const override { return reloc_iterator_.done(); }
   void Next() override;
 
   bool IsDebugBreak() override;
   void ClearDebugBreak() override;
   void SetDebugBreak() override;
 
   void SkipToPosition(int position, BreakPositionAlignment alignment);
 
   int code_offset() override {
     return static_cast<int>(rinfo()->pc() -
                             debug_info_->DebugCode()->instruction_start());
   }
 
  private:
-  int GetModeMask(BreakLocatorType type);
+  int GetModeMask();
   DebugBreakType GetDebugBreakType();
 
   RelocInfo::Mode rmode() { return reloc_iterator_.rinfo()->rmode(); }
   RelocInfo* rinfo() { return reloc_iterator_.rinfo(); }
 
   RelocIterator reloc_iterator_;
   SourcePositionTableIterator source_position_iterator_;
   DISALLOW_COPY_AND_ASSIGN(CodeBreakIterator);
 };
 
 class BytecodeArrayBreakIterator : public BreakIterator {
  public:
-  BytecodeArrayBreakIterator(Handle<DebugInfo> debug_info,
-                             BreakLocatorType type);
+  explicit BytecodeArrayBreakIterator(Handle<DebugInfo> debug_info);
   ~BytecodeArrayBreakIterator() override {}
 
   BreakLocation GetBreakLocation() override;
   bool Done() const override { return source_position_iterator_.done(); }
   void Next() override;
 
   bool IsDebugBreak() override;
   void ClearDebugBreak() override;
   void SetDebugBreak() override;
 
@@ skipping 140 matching lines @@
   void RunPromiseHook(PromiseHookType type, Handle<JSPromise> promise,
                       Handle<Object> parent);
 
   int NextAsyncTaskId(Handle<JSObject> promise);
 
   bool IsBlackboxed(Handle<SharedFunctionInfo> shared);
 
   void SetDebugDelegate(debug::DebugDelegate* delegate);
 
   // Returns whether the operation succeeded. Compilation can only be triggered
   // if a valid closure is passed as the second argument, otherwise the shared

[jgruber, 2017/01/30 15:42:17]

Comment seems outdated.

   // function needs to be compiled already.
-  bool EnsureDebugInfo(Handle<SharedFunctionInfo> shared,
-                       Handle<JSFunction> function);
+  bool EnsureDebugInfo(Handle<SharedFunctionInfo> shared);
   void CreateDebugInfo(Handle<SharedFunctionInfo> shared);
   static Handle<DebugInfo> GetDebugInfo(Handle<SharedFunctionInfo> shared);
 
   template <typename C>
   bool CompileToRevealInnerFunctions(C* compilable);
 
   // This function is used in FunctionNameUsing* tests.
   Handle<Object> FindSharedFunctionInfoInScript(Handle<Script> script,
                                                 int position);
 
@@ skipping 87 matching lines @@
  private:
   explicit Debug(Isolate* isolate);
 
   void UpdateState();
   void UpdateHookOnFunctionCall();
   void Unload();
   void SetNextBreakId() {
     thread_local_.break_id_ = ++thread_local_.break_count_;
   }
 
+  // Return the number of virtual frames below debugger entry.
+  int CurrentFrameCount();
+
   inline bool ignore_events() const {
     return is_suppressed_ || !is_active_ || isolate_->needs_side_effect_check();
   }
   inline bool break_disabled() const {
     return break_disabled_ || in_debug_event_listener_;
   }
 
   void clear_suspended_generator() {
     thread_local_.suspended_generator_ = Smi::kZero;
   }
 
   bool has_suspended_generator() const {
     return thread_local_.suspended_generator_ != Smi::kZero;
   }
 
   // There are three types of event listeners: C++ message_handler,
   // JavaScript event listener and C++ event listener.
   // Currently inspector still uses C++ event listener and installs
   // more specific event listeners for part of events. Calling of
   // C++ event listener is redundant when more specific event listener
   // is presented. Other clients can install JavaScript event listener
   // (e.g. some of NodeJS module).
   bool non_inspector_listener_exists() const {
     return !event_listener_.is_null() && !event_listener_->IsForeign();
   }
 
-  bool IsBlackboxed(SharedFunctionInfo* shared);
   bool IsExceptionBlackboxed(bool uncaught);
 
   void OnException(Handle<Object> exception, Handle<Object> promise);
 
   // Constructors for debug event objects.
   MUST_USE_RESULT MaybeHandle<Object> MakeExecutionState();
   MUST_USE_RESULT MaybeHandle<Object> MakeBreakEvent(
       Handle<Object> break_points_hit);
   MUST_USE_RESULT MaybeHandle<Object> MakeExceptionEvent(
       Handle<Object> exception,
@@ skipping 13 matching lines @@
   // Find the closest source position for a break point for a given position.
   int FindBreakablePosition(Handle<DebugInfo> debug_info, int source_position,
                             BreakPositionAlignment alignment);
   // Instrument code to break at break points.
   void ApplyBreakPoints(Handle<DebugInfo> debug_info);
   // Clear code from instrumentation.
   void ClearBreakPoints(Handle<DebugInfo> debug_info);
   // Clear all code from instrumentation.
   void ClearAllBreakPoints();
   // Instrument a function with one-shots.
-  void FloodWithOneShot(Handle<JSFunction> function,
-                        BreakLocatorType type = ALL_BREAK_LOCATIONS);
+  void FloodWithOneShot(Handle<SharedFunctionInfo> function);
   // Clear all one-shot instrumentations, but restore break points.
   void ClearOneShot();
 
   void ActivateStepOut(StackFrame* frame);
   void RemoveDebugInfoAndClearFromShared(Handle<DebugInfo> debug_info);
   MaybeHandle<FixedArray> CheckBreakPoints(Handle<DebugInfo> debug_info,
                                            BreakLocation* location,
                                            bool* has_break_points = nullptr);
   bool IsMutedAtCurrentLocation(JavaScriptFrame* frame);
   bool CheckBreakPoint(Handle<Object> break_point_object);
@@ skipping 64 matching lines @@
     // Frame id for the frame of the current break.
     StackFrame::Id break_frame_id_;
 
     // Step action for last step performed.
     StepAction last_step_action_;
 
     // Source statement position from last step next action.
     int last_statement_position_;
 
     // Frame pointer from last step next or step frame action.
-    Address last_fp_;
+    int last_frame_count_;
 
     // Frame pointer of the target frame we want to arrive at.
-    Address target_fp_;
+    int target_frame_count_;
 
     // Stores the way how LiveEdit has patched the stack. It is used when
     // debugger returns control back to user script.
     LiveEditFrameDropMode frame_drop_mode_;
 
     // Value of accumulator in interpreter frames. In non-interpreter frames
     // this value will be the hole.
     Handle<Object> return_value_;
 
     Object* suspended_generator_;
@@ skipping 127 matching lines @@
                                   Handle<Code> code);
   static bool DebugBreakSlotIsPatched(Address pc);
   static void ClearDebugBreakSlot(Isolate* isolate, Address pc);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_H_