[interpreter, debugger] support debug breaks via bytecode array copy

src/interpreter/interpreter-assembler.cc

 // Copyright 2015 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.
 
 #include "src/interpreter/interpreter-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/frames.h"
@@ skipping 390 matching lines @@
 void InterpreterAssembler::JumpIfWordNotEqual(Node* lhs, Node* rhs,
                                               Node* delta) {
   JumpConditional(WordNotEqual(lhs, rhs), delta);
 }
 
 void InterpreterAssembler::Dispatch() {
   DispatchTo(Advance(Bytecodes::Size(bytecode_)));
 }
 
 void InterpreterAssembler::DispatchTo(Node* new_bytecode_offset) {
-  if (FLAG_trace_ignition) {
-    TraceBytecode(Runtime::kInterpreterTraceBytecodeExit);
-  }
   Node* target_bytecode = Load(
       MachineType::Uint8(), BytecodeArrayTaggedPointer(), new_bytecode_offset);
 
   // TODO(rmcilroy): Create a code target dispatch table to avoid conversion
   // from code object on every dispatch.
   Node* target_code_object =
       Load(MachineType::Pointer(), DispatchTableRawPointer(),
            Word32Shl(target_bytecode, Int32Constant(kPointerSizeLog2)));
 
+  DispatchToBytecodeHandler(target_code_object, new_bytecode_offset);
+}
+
+void InterpreterAssembler::DispatchToBytecodeHandler(Node* handler,
+                                                     Node* bytecode_offset) {
+  if (FLAG_trace_ignition) {
+    TraceBytecode(Runtime::kInterpreterTraceBytecodeExit);
+  }
+
+  if (bytecode_offset == nullptr) bytecode_offset = BytecodeOffset();

[rmcilroy, 2016/02/19 14:47:16]

Could you avoid this and the default argument type and just pass
BytecodeOffset() explicitly where necessary please (either make BytecodeOffset
public or add a 1 arg variant of DispatchToBytecodeHandler which calls this one
with BytecodeOffset() as the second arg).

+
   InterpreterDispatchDescriptor descriptor(isolate());
   Node* args[] = {GetAccumulator(),          RegisterFileRawPointer(),
-                  new_bytecode_offset,       BytecodeArrayTaggedPointer(),
+                  bytecode_offset,           BytecodeArrayTaggedPointer(),
                   DispatchTableRawPointer(), GetContext()};
-  TailCall(descriptor, target_code_object, args, 0);
+  TailCall(descriptor, handler, args, 0);
 }
 
 void InterpreterAssembler::InterpreterReturn() {
-  if (FLAG_trace_ignition) {
-    TraceBytecode(Runtime::kInterpreterTraceBytecodeExit);
-  }
-  InterpreterDispatchDescriptor descriptor(isolate());
   Node* exit_trampoline_code_object =
       HeapConstant(isolate()->builtins()->InterpreterExitTrampoline());
-  Node* args[] = {GetAccumulator(),          RegisterFileRawPointer(),
-                  BytecodeOffset(),          BytecodeArrayTaggedPointer(),
-                  DispatchTableRawPointer(), GetContext()};
-  TailCall(descriptor, exit_trampoline_code_object, args, 0);
+  DispatchToBytecodeHandler(exit_trampoline_code_object);
 }
 
 void InterpreterAssembler::StackCheck() {
   CodeStubAssembler::Label end(this);
   CodeStubAssembler::Label ok(this);
   CodeStubAssembler::Label stack_guard(this);
 
   Node* sp = LoadStackPointer();
   Node* stack_limit = Load(
       MachineType::Pointer(),
@@ skipping 43 matching lines @@
 #elif V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_X87
   return true;
 #else
 #error "Unknown Architecture"
 #endif
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8