[generators] Perform state dispatch in loop header.

src/interpreter/bytecode-array-builder.h

 // 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.
 
 #ifndef V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_
 #define V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_
 
 #include "src/ast/ast.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/interpreter/bytecodes.h"
@@ skipping 206 matching lines @@
   BytecodeArrayBuilder& Bind(BytecodeLabel* label);
   BytecodeArrayBuilder& Bind(const BytecodeLabel& target, BytecodeLabel* label);
 
   BytecodeArrayBuilder& Jump(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfTrue(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfFalse(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfNotHole(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfNull(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfUndefined(BytecodeLabel* label);
 
+  // Jump to targets[value], where min <= value < min + size.
+  BytecodeArrayBuilder& IndexedJump(Register value, int min, size_t size,
+                                    ZoneVector<BytecodeLabel>& targets);
+
   BytecodeArrayBuilder& StackCheck();
 
   BytecodeArrayBuilder& Throw();
   BytecodeArrayBuilder& ReThrow();
   BytecodeArrayBuilder& Return();
 
   BytecodeArrayBuilder& Illegal();
 
   // Debugger.
   BytecodeArrayBuilder& Debugger();
@@ skipping 41 matching lines @@
   static OperandSize SizeForSignedOperand(int value);
   static OperandSize SizeForUnsignedOperand(int value);
   static OperandSize SizeForUnsignedOperand(size_t value);
 
   static uint32_t RegisterOperand(Register reg);
   static Register RegisterFromOperand(uint32_t operand);
   static uint32_t SignedOperand(int value, OperandSize size);
   static uint32_t UnsignedOperand(int value);
   static uint32_t UnsignedOperand(size_t value);
 
+  ZoneVector<BytecodeLabel> generator_resume_points;
+  int generator_yields_seen() const { return generator_yields_seen_; }
+  int incr_generator_yields_seen() { return generator_yields_seen_++; }
+
  private:
   class PreviousBytecodeHelper;
   friend class BytecodeRegisterAllocator;
 
   static Bytecode BytecodeForBinaryOperation(Token::Value op);
   static Bytecode BytecodeForCountOperation(Token::Value op);
   static Bytecode BytecodeForCompareOperation(Token::Value op);
   static Bytecode BytecodeForStoreIC(LanguageMode language_mode);
   static Bytecode BytecodeForKeyedStoreIC(LanguageMode language_mode);
   static Bytecode BytecodeForLoadGlobal(TypeofMode typeof_mode);
@@ skipping 72 matching lines @@
   SourcePositionTableBuilder source_position_table_builder_;
   size_t last_block_end_;
   size_t last_bytecode_start_;
   bool exit_seen_in_block_;
   int unbound_jumps_;
   int parameter_count_;
   int local_register_count_;
   int context_register_count_;
   int return_position_;
   TemporaryRegisterAllocator temporary_allocator_;
+  int generator_yields_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeArrayBuilder);
 };
 
 
 // A label representing a branch target in a bytecode array. When a
 // label is bound, it represents a known position in the bytecode
 // array. For labels that are forward references there can be at most
 // one reference whilst it is unbound.
 class BytecodeLabel final {
@@ skipping 30 matching lines @@
   size_t offset_;
 
   friend class BytecodeArrayBuilder;
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_