[generators] Perform state dispatch in loop header.

src/interpreter/bytecode-array-builder.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/bytecode-array-builder.h"
 #include "src/compiler.h"
 #include "src/interpreter/interpreter-intrinsics.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 78 matching lines @@
   Bytecode bytecode_;
   size_t previous_bytecode_start_;
 
   DISALLOW_COPY_AND_ASSIGN(PreviousBytecodeHelper);
 };
 
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate, Zone* zone,
                                            int parameter_count,
                                            int context_count, int locals_count,
                                            FunctionLiteral* literal)
-    : isolate_(isolate),
+    : generator_resume_points(0, zone),
+      isolate_(isolate),
       zone_(zone),
       bytecodes_(zone),
       bytecode_generated_(false),
       constant_array_builder_(isolate, zone),
       handler_table_builder_(isolate, zone),
       source_position_table_builder_(isolate, zone),
       last_block_end_(0),
       last_bytecode_start_(~0),
       exit_seen_in_block_(false),
       unbound_jumps_(0),
       parameter_count_(parameter_count),
       local_register_count_(locals_count),
       context_register_count_(context_count),
-      temporary_allocator_(zone, fixed_register_count()) {
+      temporary_allocator_(zone, fixed_register_count()),
+      generator_yields_seen_(0) {
   DCHECK_GE(parameter_count_, 0);
   DCHECK_GE(context_register_count_, 0);
   DCHECK_GE(local_register_count_, 0);
   return_position_ =
       literal ? std::max(literal->start_position(), literal->end_position() - 1)
               : RelocInfo::kNoPosition;
   LOG_CODE_EVENT(isolate_, CodeStartLinePosInfoRecordEvent(
                                source_position_table_builder()));
 }
 
@@ skipping 744 matching lines @@
 BytecodeArrayBuilder& BytecodeArrayBuilder::StackCheck() {
   Output(Bytecode::kStackCheck);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotHole(
     BytecodeLabel* label) {
   return OutputJump(Bytecode::kJumpIfNotHole, label);
 }
 
+
+BytecodeArrayBuilder& BytecodeArrayBuilder::IndexedJump(

[rmcilroy, 2016/04/19 09:30:03]

As mentioned in a comment below, I think this should also live in the
BytecodeGenerator (along with the resume points and yields seen). Doing this
here breaks the abstraction between BytecodeGenerator (which is meant to be
where the logic of turning JS into bytecode lives) and BytecodeArrayBuilder
(which is meant to simply abstract over bytecode creation and output).

[neis, 2016/04/19 11:02:15]

Ack.  I thought my IndexedJump would fit well next to the JumpIfFoo functions
but I didn't realize that those all have their own bytecode.

+    Register index, int min, size_t size, ZoneVector<BytecodeLabel>& targets) {
+  // TODO(neis): Optimize this by using a proper jump table.
+  for (int i = min; i < min + size; i++) {
+    DCHECK(0 <= i && i < targets.size());
+    LoadLiteral(Smi::FromInt(static_cast<int>(i)));
+    CompareOperation(Token::Value::EQ_STRICT, index);
+    JumpIfTrue(&(targets[i]));
+  }
+  Illegal();  // Should never get here.
+  return *this;
+}
+
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::Throw() {
   Output(Bytecode::kThrow);
   exit_seen_in_block_ = true;
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ReThrow() {
   Output(Bytecode::kReThrow);
   exit_seen_in_block_ = true;
@@ skipping 601 matching lines @@
 }
 
 uint32_t BytecodeArrayBuilder::UnsignedOperand(size_t value) {
   DCHECK_LE(value, kMaxUInt32);
   return static_cast<uint32_t>(value);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8