[interpreter, debugger] implement bytecode break location iterator.

src/interpreter/bytecode-array-builder.cc

Index: src/interpreter/bytecode-array-builder.cc
diff --git a/src/interpreter/bytecode-array-builder.cc b/src/interpreter/bytecode-array-builder.cc
index 91905079d113b0b85a61dda9a9a8bed17a651e4f..db90d56f34b1315e17aff71dab58c10c66aeea6e 100644
--- a/src/interpreter/bytecode-array-builder.cc
+++ b/src/interpreter/bytecode-array-builder.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "src/interpreter/bytecode-array-builder.h"
+#include "src/compiler.h"
 
 namespace v8 {
 namespace internal {
@@ -115,7 +116,7 @@ bool BytecodeArrayBuilder::RegisterIsParameterOrLocal(Register reg) const {
 
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK_EQ(bytecode_generated_, false);
-  EnsureReturn();
+  DCHECK(exit_seen_in_block_);
 
   int bytecode_size = static_cast<int>(bytecodes_.size());
   int register_count =
@@ -1074,10 +1075,10 @@ void BytecodeArrayBuilder::LeaveBasicBlock() {
   exit_seen_in_block_ = false;
 }
 
-
-void BytecodeArrayBuilder::EnsureReturn() {
+void BytecodeArrayBuilder::EnsureReturn(FunctionLiteral* literal) {
   if (!exit_seen_in_block_) {
     LoadUndefined();
+    SetReturnPosition(literal);

[vogelheim, 2016/02/11 12:33:59]

I find the SetReturnPosition handling a bit odd. Not sure I understand how this
works, so feel free to ignore. By my reading:

- BytecodeArrayBuilder::SetReturnPosition will add a statement position to the
end of the function. This is independent of actual "return" statements in the
code: it should always be there.
- It's called for each actual return, and if there was none in the source, then
EnsureReturn will synthesize a return statement and call SetReturnPosition for
it.
- The source position table builder has logic to discard multiple return
positions, because for a function with multiple "return"s in the source, we'd
call SetReturnPosition multiple times, each time adding the same statement
position.

Wouldn't it be much simpler to just discard all of that, and instead have some
sort of 'finalize' call that will add the final statement position if it isn't
already there, and that must be called once at the end of every bytecode array
build?

[Yang, 2016/02/11 14:16:55]

This simply reflects what Fullcodegen does. All return statements have the
source position at the end of the function.

The source position table has logic to discard multiple source positions for the
same code offset. Having multiple code offsets having the same source position
is fine. In this case, we have multiple return positions in the bytecode refer
to the same source position.

The finalize call you suggest would not do the same. Any return statements in
the middle of the code would not have a source position attached.

     Return();
   }
 }
@@ -1213,6 +1214,11 @@ size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) {
   return constant_array_builder()->Insert(object);
 }
 
+void BytecodeArrayBuilder::SetReturnPosition(FunctionLiteral* fun) {
+  int pos = std::max(fun->start_position(), fun->end_position() - 1);
+  source_position_table_builder_.AddStatementPosition(bytecodes_.size(), pos);
+}
+
 void BytecodeArrayBuilder::SetStatementPosition(Statement* stmt) {
   if (stmt->position() == RelocInfo::kNoPosition) return;
   source_position_table_builder_.AddStatementPosition(bytecodes_.size(),