[debugger] fix stepping over await calls for ignition generators.

src/interpreter/interpreter.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.h"
 
 #include <fstream>
 
 #include "src/ast/prettyprinter.h"
 #include "src/code-factory.h"
@@ skipping 1773 matching lines @@
 // No operation.
 void Interpreter::DoNop(InterpreterAssembler* assembler) { __ Dispatch(); }
 
 // SuspendGenerator <generator>
 //
 // Exports the register file and stores it into the generator.  Also stores the
 // current context and the state given in the accumulator into the generator.
 void Interpreter::DoSuspendGenerator(InterpreterAssembler* assembler) {
   Node* generator_reg = __ BytecodeOperandReg(0);
   Node* generator = __ LoadRegister(generator_reg);
+  Node* context = __ GetContext();
+
+  Node* debug_is_active = __ DebuggerIsActive();
+  Label if_debugging(assembler), debugger_done(assembler);

[rmcilroy, 2016/06/14 06:23:11]

Please make if_debugging deferred. (It's the only call in this handler, so if
it's deferred the handler won't build a frame unless it enters this branch).

[Yang, 2016/06/14 09:17:02]

Done. However, I think we always build a frame for this bytecode handler.

[rmcilroy, 2016/06/14 10:00:22]

We do on ia32 due to lack of registers, but not on x64 currently. We shouldn't
need to on Arm either, but seem to for some reason, I'll look into that at some
point. Thanks.

+  __ BranchIf(debug_is_active, &if_debugging, &debugger_done);
+  __ Bind(&if_debugging);
+  {
+    __ CallRuntime(Runtime::kDebugRecordAsyncFunction, context, generator);

[caitp (gmail), 2016/06/13 13:38:13]

Is it possible to know at this point in the interpreter whether or not the
generator being suspended is an async function or not? Or does it just not
matter since it only applies to debugging anyways?

[Yang, 2016/06/13 13:42:26]

We could expand a bit more and load the function of the generator, and load the
shared function info, and then load the bitfield...

But that's pretty cumbersome, and probably doesn't matter. We only do this when
debugger is active.

+    __ Goto(&debugger_done);
+  }
+  __ Bind(&debugger_done);
 
   Node* array =
       __ LoadObjectField(generator, JSGeneratorObject::kOperandStackOffset);
-  Node* context = __ GetContext();
   Node* state = __ GetAccumulator();
 
   __ ExportRegisterFile(array);
   __ StoreObjectField(generator, JSGeneratorObject::kContextOffset, context);
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset, state);
 
   __ Dispatch();
 }
 
 // ResumeGenerator <generator>
@@ skipping 14 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8