[debugger] account for inlined functions when stepping.

test/debugger/regress/regress-5901-2.js

Index: test/debugger/regress/regress-5901-2.js
diff --git a/test/debugger/regress/regress-5901-2.js b/test/debugger/regress/regress-5901-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..becad1bb071d1f084a9676c76417eeece9645f40
--- /dev/null
+++ b/test/debugger/regress/regress-5901-2.js
@@ -0,0 +1,45 @@
+// Copyright 2017 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.
+
+function f() {
+  debugger;
+  return 1;
+}
+
+function g() {
+  return f();
+}  // Break
+
+function h() {
+  return g();
+}
+
+h();
+h();
+
+var Debug = debug.Debug;
+var step_count = 0;
+var exception = null;
+
+function listener(event, exec_state, event_data, data) {
+  if (event != Debug.DebugEvent.Break) return;
+  try {
+    if (step_count == 0) {
+      exec_state.prepareStep(Debug.StepAction.StepOut);
+    } else {
+      assertTrue(exec_state.frame().sourceLineText().includes('Break'));
+    }
+    step_count++;
+  } catch (e) {
+    exception = e;
+    print(e);
+  }
+}
+
+Debug.setListener(listener);
+% OptimizeFunctionOnNextCall(h);
+h();

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

So just to be clear, h() is optimized at this point, and is deoptimized later?
When hitting 'debugger' or when after triggering the first listener call?

[Yang, 2017/01/30 19:47:19]

h is optimized at this point, and it inlines g and f. It will be deoptimized
when we step out from f, thereby setting break points in g.
PrepareFunctionForBreakpoint will iterate the heap to find all functions that
inline g. So h will be deoptimized.

+Debug.setListener(null);
+assertNull(exception);
+assertEquals(2, step_count);