[Interpreter] Add for/while/do support to the bytecode generator.

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"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate, Zone* zone)
     : isolate_(isolate),
+      zone_(zone),
       bytecodes_(zone),
       bytecode_generated_(false),
       last_block_end_(0),
       last_bytecode_start_(~0),
       return_seen_in_block_(false),
       constants_map_(isolate->heap(), zone),
       constants_(zone),
       parameter_count_(-1),
       local_register_count_(-1),
       temporary_register_count_(0),
@@ skipping 284 matching lines @@
   if (label->is_forward_target()) {
     // An earlier jump instruction refers to this label. Update it's location.
     PatchJump(bytecodes()->end(), bytecodes()->begin() + label->offset());
     // Now treat as if the label will only be back referred to.
   }
   label->bind_to(bytecodes()->size());
   return *this;
 }
 
 
-// static
-bool BytecodeArrayBuilder::IsJumpWithImm8Operand(Bytecode jump_bytecode) {
-  return jump_bytecode == Bytecode::kJump ||
-         jump_bytecode == Bytecode::kJumpIfTrue ||
-         jump_bytecode == Bytecode::kJumpIfFalse;
+BytecodeArrayBuilder& BytecodeArrayBuilder::Bind(const BytecodeLabel& target,
+                                                 BytecodeLabel* label) {
+  DCHECK_EQ(label->is_bound(), false);
+  DCHECK_EQ(target.is_bound(), true);
+  PatchJump(bytecodes()->begin() + target.offset(),
+            bytecodes()->begin() + label->offset());
+  label->bind_to(target.offset());
+  return *this;
 }
 
 
 // static
 Bytecode BytecodeArrayBuilder::GetJumpWithConstantOperand(
     Bytecode jump_bytecode) {
   switch (jump_bytecode) {
     case Bytecode::kJump:
       return Bytecode::kJumpConstant;
     case Bytecode::kJumpIfTrue:
       return Bytecode::kJumpIfTrueConstant;
     case Bytecode::kJumpIfFalse:
       return Bytecode::kJumpIfFalseConstant;
     default:
       UNREACHABLE();
       return Bytecode::kJumpConstant;
   }
 }
 
 
 void BytecodeArrayBuilder::PatchJump(
     const ZoneVector<uint8_t>::iterator& jump_target,
     ZoneVector<uint8_t>::iterator jump_location) {
   Bytecode jump_bytecode = Bytecodes::FromByte(*jump_location);
   int delta = static_cast<int>(jump_target - jump_location);
 
-  DCHECK(IsJumpWithImm8Operand(jump_bytecode));
+  DCHECK(Bytecodes::IsJump(jump_bytecode));
   DCHECK_EQ(Bytecodes::Size(jump_bytecode), 2);
-  DCHECK_GE(delta, 0);
+  DCHECK_NE(delta, 0);
 
   if (FitsInImm8Operand(delta)) {
     // Just update the operand
     jump_location++;
     *jump_location = static_cast<uint8_t>(delta);
   } else {
     // Update the jump type and operand
     size_t entry = GetConstantPoolEntry(handle(Smi::FromInt(delta), isolate()));
     if (FitsInIdxOperand(entry)) {
-      *jump_location++ =
-          Bytecodes::ToByte(GetJumpWithConstantOperand(jump_bytecode));
+      jump_bytecode = GetJumpWithConstantOperand(jump_bytecode);
+      *jump_location++ = Bytecodes::ToByte(jump_bytecode);
       *jump_location = static_cast<uint8_t>(entry);
     } else {
       // TODO(oth): OutputJump should reserve a constant pool entry
       // when jump is written. The reservation should be used here if
       // needed, or cancelled if not. This is due to the patch needing
       // to match the size of the code it's replacing. In future,
       // there will probably be a jump with 32-bit operand for cases
       // when constant pool is full, but that needs to be emitted in
       // OutputJump too.
       UNIMPLEMENTED();
@@ skipping 233 matching lines @@
 
 Register TemporaryRegisterScope::NewRegister() {
   count_++;
   last_register_index_ = builder_->BorrowTemporaryRegister();
   return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8