[Interpreter] Basic flow control.

+ Add bytecodes for conditional and unconditional jumps.
+ Add bytecodes for test/compare operations.
+ Expose jumps in bytecode-array-builder and add BytecodeLabel class for
  identifying jump targets.
+ Add support for if..then...else in the bytecode-generator.
+ Implement jump bytecodes in the interpreter. Test/compare operations
  dependent on runtime call for comparisons.

BUG=v8:4280
LOG=N

Review URL: https://codereview.chromium.org/1343363002

Cr-Commit-Position: refs/heads/master@{#30918}

src/compiler/bytecode-graph-builder.cc

@@ -332,6 +332,108 @@ void BytecodeGraphBuilder::VisitMod(
 }
 
 
+void BytecodeGraphBuilder::VisitTestEqual(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestNotEqual(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestEqualStrict(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestNotEqualStrict(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestLessThan(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestGreaterThan(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestLessThanEqual(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestGreaterThanEqual(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestIn(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitTestInstanceOf(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitToBoolean(
+    const interpreter::BytecodeArrayIterator& ToBoolean) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitJump(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitJumpConstant(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitJumpIfTrue(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitJumpIfTrueConstant(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitJumpIfFalse(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
+void BytecodeGraphBuilder::VisitJumpIfFalseConstant(
+    const interpreter::BytecodeArrayIterator& iterator) {
+  UNIMPLEMENTED();
+}
+
+
 void BytecodeGraphBuilder::VisitReturn(
     const interpreter::BytecodeArrayIterator& iterator) {
   Node* control =

src/compiler/interpreter-assembler.cc

@@ -32,7 +32,7 @@ InterpreterAssembler::InterpreterAssembler(Isolate* isolate, Zone* zone,
           isolate, new (zone) Graph(zone),
           Linkage::GetInterpreterDispatchDescriptor(zone), kMachPtr,
           InstructionSelector::SupportedMachineOperatorFlags())),
-      end_node_(nullptr),
+      end_nodes_(zone),
       accumulator_(
           raw_assembler_->Parameter(Linkage::kInterpreterAccumulatorParameter)),
       code_generated_(false) {}
@@ -193,6 +193,11 @@ Node* InterpreterAssembler::HeapConstant(Handle<HeapObject> object) {
 }
 
 
+Node* InterpreterAssembler::BooleanConstant(bool value) {
+  return raw_assembler_->BooleanConstant(value);
+}
+
+
 Node* InterpreterAssembler::SmiShiftBitsConstant() {
   return Int32Constant(kSmiShiftSize + kSmiTagSize);
 }
@@ -348,7 +353,7 @@ void InterpreterAssembler::Return() {
   Node* tail_call = raw_assembler_->TailCallN(
       call_descriptor(), exit_trampoline_code_object, args);
   // This should always be the end node.
-  SetEndInput(tail_call);
+  AddEndInput(tail_call);
 }
 
 
@@ -357,8 +362,31 @@ Node* InterpreterAssembler::Advance(int delta) {
 }
 
 
+Node* InterpreterAssembler::Advance(Node* delta) {
+  return raw_assembler_->IntPtrAdd(BytecodeOffset(), delta);
+}
+
+
+void InterpreterAssembler::Jump(Node* delta) { DispatchTo(Advance(delta)); }
+
+
+void InterpreterAssembler::JumpIfWordEqual(Node* lhs, Node* rhs, Node* delta) {
+  RawMachineAssembler::Label match, no_match;
+  Node* condition = raw_assembler_->WordEqual(lhs, rhs);
+  raw_assembler_->Branch(condition, &match, &no_match);
+  raw_assembler_->Bind(&match);
+  DispatchTo(Advance(delta));
+  raw_assembler_->Bind(&no_match);
+  Dispatch();
+}
+
+
 void InterpreterAssembler::Dispatch() {
-  Node* new_bytecode_offset = Advance(interpreter::Bytecodes::Size(bytecode_));
+  DispatchTo(Advance(interpreter::Bytecodes::Size(bytecode_)));
+}
+
+
+void InterpreterAssembler::DispatchTo(Node* new_bytecode_offset) {
   Node* target_bytecode = raw_assembler_->Load(
       kMachUint8, BytecodeArrayTaggedPointer(), new_bytecode_offset);
 
@@ -385,20 +413,21 @@ void InterpreterAssembler::Dispatch() {
   Node* tail_call =
       raw_assembler_->TailCallN(call_descriptor(), target_code_object, args);
   // This should always be the end node.
-  SetEndInput(tail_call);
+  AddEndInput(tail_call);
 }
 
 
-void InterpreterAssembler::SetEndInput(Node* input) {
-  DCHECK(!end_node_);
-  end_node_ = input;
+void InterpreterAssembler::AddEndInput(Node* input) {
+  DCHECK_NOT_NULL(input);
+  end_nodes_.push_back(input);
 }
 
 
 void InterpreterAssembler::End() {
-  DCHECK(end_node_);
-  // TODO(rmcilroy): Support more than 1 end input.
-  Node* end = graph()->NewNode(raw_assembler_->common()->End(1), end_node_);
+  DCHECK(!end_nodes_.empty());
+  int end_count = static_cast<int>(end_nodes_.size());
+  Node* end = graph()->NewNode(raw_assembler_->common()->End(end_count),
+                               end_count, &end_nodes_[0]);
   graph()->SetEnd(end);
 }
 

src/compiler/interpreter-assembler.h

@@ -13,6 +13,7 @@
 #include "src/frames.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/runtime/runtime.h"
+#include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
@@ -68,6 +69,7 @@ class InterpreterAssembler {
   Node* IntPtrConstant(intptr_t value);
   Node* NumberConstant(double value);
   Node* HeapConstant(Handle<HeapObject> object);
+  Node* BooleanConstant(bool value);
 
   // Tag and untag Smi values.
   Node* SmiTag(Node* value);
@@ -107,6 +109,13 @@ class InterpreterAssembler {
   Node* CallRuntime(Runtime::FunctionId function_id, Node* arg1);
   Node* CallRuntime(Runtime::FunctionId function_id, Node* arg1, Node* arg2);
 
+  // Jump relative to the current bytecode by |jump_offset|.
+  void Jump(Node* jump_offset);
+
+  // Jump relative to the current bytecode by |jump_offset| if the
+  // word values |lhs| and |rhs| are equal.
+  void JumpIfWordEqual(Node* lhs, Node* rhs, Node* jump_offset);
+
   // Returns from the function.
   void Return();
 
@@ -147,9 +156,13 @@ class InterpreterAssembler {
   // Returns BytecodeOffset() advanced by delta bytecodes. Note: this does not
   // update BytecodeOffset() itself.
   Node* Advance(int delta);
+  Node* Advance(Node* delta);
+
+  // Starts next instruction dispatch at |new_bytecode_offset|.
+  void DispatchTo(Node* new_bytecode_offset);
 
-  // Sets the end node of the graph.
-  void SetEndInput(Node* input);
+  // Adds an end node of the graph.
+  void AddEndInput(Node* input);
 
   // Private helpers which delegate to RawMachineAssembler.
   Isolate* isolate();
@@ -158,7 +171,7 @@ class InterpreterAssembler {
 
   interpreter::Bytecode bytecode_;
   base::SmartPointer<RawMachineAssembler> raw_assembler_;
-  Node* end_node_;
+  ZoneVector<Node*> end_nodes_;
   Node* accumulator_;
   bool code_generated_;
 

src/compiler/raw-machine-assembler.cc

@@ -153,6 +153,7 @@ Node* RawMachineAssembler::TailCallN(CallDescriptor* desc, Node* function,
   buffer[index++] = graph()->start();
   Node* tail_call = MakeNode(common()->TailCall(desc), input_count, buffer);
   schedule()->AddTailCall(CurrentBlock(), tail_call);
+  current_block_ = nullptr;
   return tail_call;
 }
 

src/compiler/raw-machine-assembler.h

@@ -73,8 +73,7 @@ class RawMachineAssembler {
   // hence will not switch the current basic block.
 
   Node* UndefinedConstant() {
-    Handle<HeapObject> undefined = isolate()->factory()->undefined_value();
-    return AddNode(common()->HeapConstant(undefined));
+    return HeapConstant(isolate()->factory()->undefined_value());
   }
 
   // Constants.
@@ -104,6 +103,10 @@ class RawMachineAssembler {
   Node* HeapConstant(Handle<HeapObject> object) {
     return AddNode(common()->HeapConstant(object));
   }
+  Node* BooleanConstant(bool value) {
+    Handle<Object> object = isolate()->factory()->ToBoolean(value);
+    return HeapConstant(Handle<HeapObject>::cast(object));
+  }
   Node* ExternalConstant(ExternalReference address) {
     return AddNode(common()->ExternalConstant(address));
   }

src/interpreter/bytecode-array-builder.h

@@ -20,6 +20,7 @@ class Isolate;
 
 namespace interpreter {
 
+class BytecodeLabel;
 class Register;
 
 class BytecodeArrayBuilder {
@@ -35,9 +36,6 @@ class BytecodeArrayBuilder {
   void set_locals_count(int number_of_locals);
   int locals_count() const;
 
-  // Returns true if the bytecode has an explicit return at the end.
-  bool HasExplicitReturn();
-
   Register Parameter(int parameter_index);
 
   // Constant loads to accumulator.
@@ -77,33 +75,69 @@ class BytecodeArrayBuilder {
   BytecodeArrayBuilder& Call(Register callable, Register receiver,
                              size_t arg_count);
 
-  // Operators.
+  // Operators (register == lhs, accumulator = rhs).
   BytecodeArrayBuilder& BinaryOperation(Token::Value binop, Register reg);
 
+  // Tests.
+  BytecodeArrayBuilder& CompareOperation(Token::Value op, Register reg,
+                                         LanguageMode language_mode);
+
+  // Casts
+  BytecodeArrayBuilder& CastAccumulatorToBoolean();
+
   // Flow Control.
+  BytecodeArrayBuilder& Bind(BytecodeLabel* label);
+  BytecodeArrayBuilder& Jump(BytecodeLabel* label);
+  BytecodeArrayBuilder& JumpIfTrue(BytecodeLabel* label);
+  BytecodeArrayBuilder& JumpIfFalse(BytecodeLabel* label);
   BytecodeArrayBuilder& Return();
 
+  BytecodeArrayBuilder& EnterBlock();
+  BytecodeArrayBuilder& LeaveBlock();
+
  private:
-  static Bytecode BytecodeForBinaryOperation(Token::Value op);
-  static bool FitsInByteOperand(int value);
-  static bool FitsInByteOperand(size_t value);
+  ZoneVector<uint8_t>* bytecodes() { return &bytecodes_; }
+  const ZoneVector<uint8_t>* bytecodes() const { return &bytecodes_; }
+  Isolate* isolate() const { return isolate_; }
 
-  void Output(Bytecode bytecode, uint8_t r0, uint8_t r1, uint8_t r2);
-  void Output(Bytecode bytecode, uint8_t r0, uint8_t r1);
-  void Output(Bytecode bytecode, uint8_t r0);
+  static Bytecode BytecodeForBinaryOperation(Token::Value op);
+  static Bytecode BytecodeForCompareOperation(Token::Value op);
+  static bool FitsInIdxOperand(int value);
+  static bool FitsInIdxOperand(size_t value);
+  static bool FitsInImm8Operand(int value);
+  static bool IsJumpWithImm8Operand(Bytecode jump_bytecode);
+  static Bytecode GetJumpWithConstantOperand(Bytecode jump_with_smi8_operand);
+
+  template <size_t N>
+  INLINE(void Output(uint8_t(&bytes)[N]));
+  void Output(Bytecode bytecode, uint8_t operand0, uint8_t operand1,
+              uint8_t operand2);
+  void Output(Bytecode bytecode, uint8_t operand0, uint8_t operand1);
+  void Output(Bytecode bytecode, uint8_t operand0);
   void Output(Bytecode bytecode);
+  void PatchJump(const ZoneVector<uint8_t>::iterator& jump_target,
+                 ZoneVector<uint8_t>::iterator jump_location);
+  BytecodeArrayBuilder& OutputJump(Bytecode jump_bytecode,
+                                   BytecodeLabel* label);
+
+  void EnsureReturn();
 
   bool OperandIsValid(Bytecode bytecode, int operand_index,
                       uint8_t operand_value) const;
+  bool LastBytecodeInSameBlock() const;
 
   size_t GetConstantPoolEntry(Handle<Object> object);
 
+  // Scope helpers used by TemporaryRegisterScope
   int BorrowTemporaryRegister();
   void ReturnTemporaryRegister(int reg_index);
 
   Isolate* isolate_;
   ZoneVector<uint8_t> bytecodes_;
   bool bytecode_generated_;
+  size_t last_block_end_;
+  size_t last_bytecode_start_;
+  bool return_seen_in_block_;
 
   IdentityMap<size_t> constants_map_;
   ZoneVector<Handle<Object>> constants_;
@@ -117,6 +151,47 @@ class BytecodeArrayBuilder {
   DISALLOW_IMPLICIT_CONSTRUCTORS(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 {
+ public:
+  BytecodeLabel() : bound_(false), offset_(kInvalidOffset) {}
+  ~BytecodeLabel() { DCHECK(bound_ && offset_ != kInvalidOffset); }
+
+ private:
+  static const size_t kInvalidOffset = static_cast<size_t>(-1);
+
+  INLINE(void bind_to(size_t offset)) {
+    DCHECK(!bound_ && offset != kInvalidOffset);
+    offset_ = offset;
+    bound_ = true;
+  }
+  INLINE(void set_referrer(size_t offset)) {
+    DCHECK(!bound_ && offset != kInvalidOffset);
+    offset_ = offset;
+  }
+  INLINE(size_t offset() const) { return offset_; }
+  INLINE(bool is_bound() const) { return bound_; }
+  INLINE(bool is_forward_target() const) {
+    return offset() != kInvalidOffset && !is_bound();
+  }
+
+  // There are three states for a label:
+  //                    bound_   offset_
+  //  UNSET             false    kInvalidOffset
+  //  FORWARD_TARGET    false    Offset of referring jump
+  //  BACKWARD_TARGET    true    Offset of label in bytecode array when bound
+  bool bound_;
+  size_t offset_;
+
+  friend class BytecodeArrayBuilder;
+  DISALLOW_COPY_AND_ASSIGN(BytecodeLabel);
+};
+
+
 // A stack-allocated class than allows the instantiator to allocate
 // temporary registers that are cleaned up when scope is closed.
 class TemporaryRegisterScope {

src/interpreter/bytecode-array-iterator.h

@@ -20,6 +20,7 @@ class BytecodeArrayIterator {
   void Advance();
   bool done() const;
   Bytecode current_bytecode() const;
+  int current_offset() const { return bytecode_offset_; }
   const Handle<BytecodeArray>& bytecode_array() const {
     return bytecode_array_;
   }

src/interpreter/bytecode-generator.cc

@@ -45,13 +45,6 @@ Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
   // Visit statements in the function body.
   VisitStatements(info->literal()->body());
 
-  // If the last bytecode wasn't a return, then return 'undefined' to avoid
-  // falling off the end.
-  if (!builder_.HasExplicitReturn()) {
-    builder_.LoadUndefined();
-    builder_.Return();
-  }
-
   set_scope(nullptr);
   set_info(nullptr);
   return builder_.ToBytecodeArray();
@@ -59,6 +52,7 @@ Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
 
 
 void BytecodeGenerator::VisitBlock(Block* node) {
+  builder().EnterBlock();
   if (node->scope() == NULL) {
     // Visit statements in the same scope, no declarations.
     VisitStatements(node->statements());
@@ -71,6 +65,7 @@ void BytecodeGenerator::VisitBlock(Block* node) {
       VisitStatements(node->statements());
     }
   }
+  builder().LeaveBlock();
 }
 
 
@@ -114,11 +109,26 @@ void BytecodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
 
 
 void BytecodeGenerator::VisitEmptyStatement(EmptyStatement* stmt) {
-  UNIMPLEMENTED();
+  // TODO(oth): For control-flow it could be useful to signal empty paths here.
 }
 
 
-void BytecodeGenerator::VisitIfStatement(IfStatement* stmt) { UNIMPLEMENTED(); }
+void BytecodeGenerator::VisitIfStatement(IfStatement* stmt) {
+  BytecodeLabel else_start, else_end;
+  // TODO(oth): Spot easy cases where there code would not need to
+  // emit the then block or the else block, e.g. condition is
+  // obviously true/1/false/0.
+  Visit(stmt->condition());
+  builder().CastAccumulatorToBoolean();
+  builder().JumpIfFalse(&else_start);
+
+  Visit(stmt->then_statement());
+  builder().Jump(&else_end);
+  builder().Bind(&else_start);
+
+  Visit(stmt->else_statement());
+  builder().Bind(&else_end);
+}
 
 
 void BytecodeGenerator::VisitSloppyBlockFunctionStatement(
@@ -478,7 +488,17 @@ void BytecodeGenerator::VisitBinaryOperation(BinaryOperation* binop) {
 
 
 void BytecodeGenerator::VisitCompareOperation(CompareOperation* expr) {
-  UNIMPLEMENTED();
+  Token::Value op = expr->op();
+  Expression* left = expr->left();
+  Expression* right = expr->right();
+
+  TemporaryRegisterScope temporary_register_scope(&builder_);
+  Register temporary = temporary_register_scope.NewRegister();
+
+  Visit(left);
+  builder().StoreAccumulatorInRegister(temporary);
+  Visit(right);
+  builder().CompareOperation(op, temporary, language_mode());
 }
 
 

src/interpreter/bytecodes.cc

@@ -133,7 +133,7 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start,
         os << "[" << static_cast<unsigned int>(operand) << "]";
         break;
       case interpreter::OperandType::kImm8:
-        os << "#" << static_cast<int>(operand);
+        os << "#" << static_cast<int>(static_cast<int8_t>(operand));
         break;
       case interpreter::OperandType::kReg: {
         Register reg = Register::FromOperand(operand);

src/interpreter/bytecodes.h

@@ -61,7 +61,28 @@ namespace interpreter {
   /* Call operations. */                                                   \
   V(Call, OperandType::kReg, OperandType::kReg, OperandType::kCount)       \
                                                                            \
+  /* Test Operators */                                                     \
+  V(TestEqual, OperandType::kReg)                                          \
+  V(TestNotEqual, OperandType::kReg)                                       \
+  V(TestEqualStrict, OperandType::kReg)                                    \
+  V(TestNotEqualStrict, OperandType::kReg)                                 \
+  V(TestLessThan, OperandType::kReg)                                       \
+  V(TestGreaterThan, OperandType::kReg)                                    \
+  V(TestLessThanEqual, OperandType::kReg)                                  \
+  V(TestGreaterThanEqual, OperandType::kReg)                               \
+  V(TestInstanceOf, OperandType::kReg)                                     \
+  V(TestIn, OperandType::kReg)                                             \
+                                                                           \
+  /* Cast operators */                                                     \
+  V(ToBoolean, OperandType::kNone)                                         \
+                                                                           \
   /* Control Flow */                                                       \
+  V(Jump, OperandType::kImm8)                                              \
+  V(JumpConstant, OperandType::kIdx)                                       \
+  V(JumpIfTrue, OperandType::kImm8)                                        \
+  V(JumpIfTrueConstant, OperandType::kIdx)                                 \
+  V(JumpIfFalse, OperandType::kImm8)                                       \
+  V(JumpIfFalseConstant, OperandType::kIdx)                                \
   V(Return, OperandType::kNone)
 
 

src/interpreter/interpreter.cc

@@ -294,6 +294,15 @@ void Interpreter::DoBinaryOp(Runtime::FunctionId function_id,
 }
 
 
+void Interpreter::DoCompareOp(Token::Value op,
+                              compiler::InterpreterAssembler* assembler) {
+  // TODO(oth): placeholder until compare path fixed.
+  // The accumulator should be set to true on success (or false otherwise)
+  // by the comparisons so it can be used for conditional jumps.
+  DoLdaTrue(assembler);
+}
+
+
 // Add <src>
 //
 // Add register <src> to accumulator.
@@ -350,6 +359,178 @@ void Interpreter::DoCall(compiler::InterpreterAssembler* assembler) {
 }
 
 
+// TestEqual <src>
+//
+// Test if the value in the <src> register equals the accumulator.
+void Interpreter::DoTestEqual(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::EQ, assembler);
+}
+
+
+// TestNotEqual <src>
+//
+// Test if the value in the <src> register is not equal to the accumulator.
+void Interpreter::DoTestNotEqual(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::NE, assembler);
+}
+
+
+// TestEqualStrict <src>
+//
+// Test if the value in the <src> register is strictly equal to the accumulator.
+void Interpreter::DoTestEqualStrict(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::EQ_STRICT, assembler);
+}
+
+
+// TestNotEqualStrict <src>
+//
+// Test if the value in the <src> register is not strictly equal to the
+// accumulator.
+void Interpreter::DoTestNotEqualStrict(
+    compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::NE_STRICT, assembler);
+}
+
+
+// TestLessThan <src>
+//
+// Test if the value in the <src> register is less than the accumulator.
+void Interpreter::DoTestLessThan(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::LT, assembler);
+}
+
+
+// TestGreaterThan <src>
+//
+// Test if the value in the <src> register is greater than the accumulator.
+void Interpreter::DoTestGreaterThan(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::GT, assembler);
+}
+
+
+// TestLessThanEqual <src>
+//
+// Test if the value in the <src> register is less than or equal to the
+// accumulator.
+void Interpreter::DoTestLessThanEqual(
+    compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::LTE, assembler);
+}
+
+
+// TestGreaterThanEqual <src>
+//
+// Test if the value in the <src> register is greater than or equal to the
+// accumulator.
+void Interpreter::DoTestGreaterThanEqual(
+    compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::GTE, assembler);
+}
+
+
+// TestIn <src>
+//
+// Test if the value in the <src> register is in the collection referenced
+// by the accumulator.
+void Interpreter::DoTestIn(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::IN, assembler);
+}
+
+
+// TestInstanceOf <src>
+//
+// Test if the object referenced by the <src> register is an an instance of type
+// referenced by the accumulator.
+void Interpreter::DoTestInstanceOf(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::INSTANCEOF, assembler);
+}
+
+
+// ToBoolean
+//
+// Cast the object referenced by the accumulator to a boolean.
+void Interpreter::DoToBoolean(compiler::InterpreterAssembler* assembler) {
+  // TODO(oth): The next CL for test operations has interpreter specific
+  // runtime calls. This looks like another candidate.
+  __ Dispatch();
+}
+
+
+// Jump <imm8>
+//
+// Jump by number of bytes represented by an immediate operand.
+void Interpreter::DoJump(compiler::InterpreterAssembler* assembler) {
+  Node* relative_jump = __ BytecodeOperandImm8(0);
+  __ Jump(relative_jump);
+}
+
+
+// JumpConstant <idx>
+//
+// Jump by number of bytes in the Smi in the |idx| entry in the constant pool.
+void Interpreter::DoJumpConstant(compiler::InterpreterAssembler* assembler) {
+  Node* index = __ BytecodeOperandIdx(0);
+  Node* constant = __ LoadConstantPoolEntry(index);
+  Node* relative_jump = __ SmiUntag(constant);
+  __ Jump(relative_jump);
+}
+
+
+// JumpIfTrue <imm8>
+//
+// Jump by number of bytes represented by an immediate operand if the
+// accumulator contains true.
+void Interpreter::DoJumpIfTrue(compiler::InterpreterAssembler* assembler) {
+  Node* accumulator = __ GetAccumulator();
+  Node* relative_jump = __ BytecodeOperandImm8(0);
+  Node* true_value = __ BooleanConstant(true);
+  __ JumpIfWordEqual(accumulator, true_value, relative_jump);
+}
+
+
+// JumpIfTrueConstant <idx>
+//
+// Jump by number of bytes in the Smi in the |idx| entry in the constant pool
+// if the accumulator contains true.
+void Interpreter::DoJumpIfTrueConstant(
+    compiler::InterpreterAssembler* assembler) {
+  Node* accumulator = __ GetAccumulator();
+  Node* index = __ BytecodeOperandIdx(0);
+  Node* constant = __ LoadConstantPoolEntry(index);
+  Node* relative_jump = __ SmiUntag(constant);
+  Node* true_value = __ BooleanConstant(true);
+  __ JumpIfWordEqual(accumulator, true_value, relative_jump);
+}
+
+
+// JumpIfFalse <imm8>
+//
+// Jump by number of bytes represented by an immediate operand if the
+// accumulator contains false.
+void Interpreter::DoJumpIfFalse(compiler::InterpreterAssembler* assembler) {
+  Node* accumulator = __ GetAccumulator();
+  Node* relative_jump = __ BytecodeOperandImm8(0);
+  Node* false_value = __ BooleanConstant(false);
+  __ JumpIfWordEqual(accumulator, false_value, relative_jump);
+}
+
+
+// JumpIfFalseConstant <idx>
+//
+// Jump by number of bytes in the Smi in the |idx| entry in the constant pool
+// if the accumulator contains false.
+void Interpreter::DoJumpIfFalseConstant(
+    compiler::InterpreterAssembler* assembler) {
+  Node* accumulator = __ GetAccumulator();
+  Node* index = __ BytecodeOperandIdx(0);
+  Node* constant = __ LoadConstantPoolEntry(index);
+  Node* relative_jump = __ SmiUntag(constant);
+  Node* false_value = __ BooleanConstant(false);
+  __ JumpIfWordEqual(accumulator, false_value, relative_jump);
+}
+
+
 // Return
 //
 // Return the value in register 0.

src/interpreter/interpreter.h

@@ -12,6 +12,7 @@
 #include "src/builtins.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/runtime/runtime.h"
+#include "src/token.h"
 
 namespace v8 {
 namespace internal {
@@ -53,6 +54,11 @@ class Interpreter {
   void DoBinaryOp(Runtime::FunctionId function_id,
                   compiler::InterpreterAssembler* assembler);
 
+  // Generates code to perform the comparison operation associated with
+  // |compare_op|.
+  void DoCompareOp(Token::Value compare_op,
+                   compiler::InterpreterAssembler* assembler);
+
   // Generates code to perform a property load via |ic|.
   void DoPropertyLoadIC(Callable ic, compiler::InterpreterAssembler* assembler);
 

test/cctest/interpreter/test-interpreter.cc

@@ -891,3 +891,86 @@ TEST(InterpreterCall) {
     CHECK(i::String::cast(*return_val)->Equals(*expected));
   }
 }
+
+
+static BytecodeArrayBuilder& SetRegister(BytecodeArrayBuilder& builder,
+                                         Register reg, int value,
+                                         Register scratch) {
+  return builder.StoreAccumulatorInRegister(scratch)
+      .LoadLiteral(Smi::FromInt(value))
+      .StoreAccumulatorInRegister(reg)
+      .LoadAccumulatorWithRegister(scratch);
+}
+
+
+static BytecodeArrayBuilder& IncrementRegister(BytecodeArrayBuilder& builder,
+                                               Register reg, int value,
+                                               Register scratch) {
+  return builder.StoreAccumulatorInRegister(scratch)
+      .LoadLiteral(Smi::FromInt(value))
+      .BinaryOperation(Token::Value::ADD, reg)
+      .StoreAccumulatorInRegister(reg)
+      .LoadAccumulatorWithRegister(scratch);
+}
+
+
+TEST(InterpreterJumps) {
+  HandleAndZoneScope handles;
+  BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+  builder.set_locals_count(2);
+  builder.set_parameter_count(0);
+  Register reg(0), scratch(1);
+  BytecodeLabel label[3];
+
+  builder.LoadLiteral(Smi::FromInt(0))
+      .StoreAccumulatorInRegister(reg)
+      .Jump(&label[1]);
+  SetRegister(builder, reg, 1024, scratch).Bind(&label[0]);
+  IncrementRegister(builder, reg, 1, scratch).Jump(&label[2]);
+  SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
+  IncrementRegister(builder, reg, 2, scratch).Jump(&label[0]);
+  SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
+  IncrementRegister(builder, reg, 4, scratch)
+      .LoadAccumulatorWithRegister(reg)
+      .Return();
+
+  Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+  InterpreterTester tester(handles.main_isolate(), bytecode_array);
+  auto callable = tester.GetCallable<>();
+  Handle<Object> return_value = callable().ToHandleChecked();
+  CHECK_EQ(Smi::cast(*return_value)->value(), 7);
+}
+
+
+TEST(InterpreterConditionalJumps) {
+  HandleAndZoneScope handles;
+  BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+  builder.set_locals_count(2);
+  builder.set_parameter_count(0);
+  Register reg(0), scratch(1);
+  BytecodeLabel label[2];
+  BytecodeLabel done, done1;
+
+  builder.LoadLiteral(Smi::FromInt(0))
+      .StoreAccumulatorInRegister(reg)
+      .LoadFalse()
+      .JumpIfFalse(&label[0]);
+  IncrementRegister(builder, reg, 1024, scratch)
+      .Bind(&label[0])
+      .LoadTrue()
+      .JumpIfFalse(&done);
+  IncrementRegister(builder, reg, 1, scratch).LoadTrue().JumpIfTrue(&label[1]);
+  IncrementRegister(builder, reg, 2048, scratch).Bind(&label[1]);
+  IncrementRegister(builder, reg, 2, scratch).LoadFalse().JumpIfTrue(&done1);
+  IncrementRegister(builder, reg, 4, scratch)
+      .LoadAccumulatorWithRegister(reg)
+      .Bind(&done)
+      .Bind(&done1)
+      .Return();
+
+  Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+  InterpreterTester tester(handles.main_isolate(), bytecode_array);
+  auto callable = tester.GetCallable<>();
+  Handle<Object> return_value = callable().ToHandleChecked();
+  CHECK_EQ(Smi::cast(*return_value)->value(), 7);
+}

test/unittests/compiler/interpreter-assembler-unittest.cc

@@ -152,6 +152,89 @@ TARGET_TEST_F(InterpreterAssemblerTest, Dispatch) {
 }
 
 
+TARGET_TEST_F(InterpreterAssemblerTest, Jump) {
+  int jump_offsets[] = {-9710, -77, 0, +3, +97109};
+  TRACED_FOREACH(int, jump_offset, jump_offsets) {
+    TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+      InterpreterAssemblerForTest m(this, bytecode);
+      m.Jump(m.Int32Constant(jump_offset));
+      Graph* graph = m.GetCompletedGraph();
+      Node* end = graph->end();
+      EXPECT_EQ(1, end->InputCount());
+      Node* tail_call_node = end->InputAt(0);
+
+      Matcher<Node*> next_bytecode_offset_matcher =
+          IsIntPtrAdd(IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
+                      IsInt32Constant(jump_offset));
+      Matcher<Node*> target_bytecode_matcher = m.IsLoad(
+          kMachUint8, IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+          next_bytecode_offset_matcher);
+      Matcher<Node*> code_target_matcher = m.IsLoad(
+          kMachPtr, IsParameter(Linkage::kInterpreterDispatchTableParameter),
+          IsWord32Shl(target_bytecode_matcher,
+                      IsInt32Constant(kPointerSizeLog2)));
+
+      EXPECT_EQ(CallDescriptor::kCallCodeObject, m.call_descriptor()->kind());
+      EXPECT_TRUE(m.call_descriptor()->flags() & CallDescriptor::kCanUseRoots);
+      EXPECT_THAT(
+          tail_call_node,
+          IsTailCall(m.call_descriptor(), code_target_matcher,
+                     IsParameter(Linkage::kInterpreterAccumulatorParameter),
+                     IsParameter(Linkage::kInterpreterRegisterFileParameter),
+                     next_bytecode_offset_matcher,
+                     IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+                     IsParameter(Linkage::kInterpreterDispatchTableParameter),
+                     IsParameter(Linkage::kInterpreterContextParameter),
+                     graph->start(), graph->start()));
+    }
+  }
+}
+
+
+TARGET_TEST_F(InterpreterAssemblerTest, JumpIfWordEqual) {
+  static const int kJumpIfTrueOffset = 73;
+
+  MachineOperatorBuilder machine(zone());
+
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    Node* lhs = m.IntPtrConstant(0);
+    Node* rhs = m.IntPtrConstant(1);
+    m.JumpIfWordEqual(lhs, rhs, m.Int32Constant(kJumpIfTrueOffset));
+    Graph* graph = m.GetCompletedGraph();
+    Node* end = graph->end();
+    EXPECT_EQ(2, end->InputCount());
+
+    int jump_offsets[] = {kJumpIfTrueOffset,
+                          interpreter::Bytecodes::Size(bytecode)};
+    for (int i = 0; i < static_cast<int>(arraysize(jump_offsets)); i++) {
+      Matcher<Node*> next_bytecode_offset_matcher =
+          IsIntPtrAdd(IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
+                      IsInt32Constant(jump_offsets[i]));
+      Matcher<Node*> target_bytecode_matcher = m.IsLoad(
+          kMachUint8, IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+          next_bytecode_offset_matcher);
+      Matcher<Node*> code_target_matcher = m.IsLoad(
+          kMachPtr, IsParameter(Linkage::kInterpreterDispatchTableParameter),
+          IsWord32Shl(target_bytecode_matcher,
+                      IsInt32Constant(kPointerSizeLog2)));
+      EXPECT_THAT(
+          end->InputAt(i),
+          IsTailCall(m.call_descriptor(), code_target_matcher,
+                     IsParameter(Linkage::kInterpreterAccumulatorParameter),
+                     IsParameter(Linkage::kInterpreterRegisterFileParameter),
+                     next_bytecode_offset_matcher,
+                     IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+                     IsParameter(Linkage::kInterpreterDispatchTableParameter),
+                     IsParameter(Linkage::kInterpreterContextParameter),
+                     graph->start(), graph->start()));
+    }
+
+    // TODO(oth): test control flow paths.
+  }
+}
+
+
 TARGET_TEST_F(InterpreterAssemblerTest, Return) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);

test/unittests/interpreter/bytecode-array-builder-unittest.cc

@@ -5,6 +5,7 @@
 #include "src/v8.h"
 
 #include "src/interpreter/bytecode-array-builder.h"
+#include "src/interpreter/bytecode-array-iterator.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
@@ -51,14 +52,39 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
   // Call operations.
   builder.Call(reg, reg, 0);
 
-  // Emit binary operators invocations.
+  // Emit binary operator invocations.
   builder.BinaryOperation(Token::Value::ADD, reg)
       .BinaryOperation(Token::Value::SUB, reg)
       .BinaryOperation(Token::Value::MUL, reg)
       .BinaryOperation(Token::Value::DIV, reg)
       .BinaryOperation(Token::Value::MOD, reg);
 
+  // Emit test operator invocations.
+  builder.CompareOperation(Token::Value::EQ, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::NE, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::EQ_STRICT, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::NE_STRICT, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::LT, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::GT, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::LTE, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::GTE, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::INSTANCEOF, reg, LanguageMode::SLOPPY)
+      .CompareOperation(Token::Value::IN, reg, LanguageMode::SLOPPY);
+
+  // Emit cast operator invocations.
+  builder.LoadNull().CastAccumulatorToBoolean();
+
   // Emit control flow. Return must be the last instruction.
+  BytecodeLabel start;
+  builder.Bind(&start);
+  // Short jumps with Imm8 operands
+  builder.Jump(&start).JumpIfTrue(&start).JumpIfFalse(&start);
+  // Insert dummy ops to force longer jumps
+  for (int i = 0; i < 128; i++) {
+    builder.LoadTrue();
+  }
+  // Longer jumps requiring Constant operand
+  builder.Jump(&start).JumpIfTrue(&start).JumpIfFalse(&start);
   builder.Return();
 
   // Generate BytecodeArray.
@@ -183,6 +209,189 @@ TEST_F(BytecodeArrayBuilderTest, Constants) {
   CHECK_EQ(array->constant_pool()->length(), 3);
 }
 
+
+TEST_F(BytecodeArrayBuilderTest, ForwardJumps) {
+  static const int kFarJumpDistance = 256;
+
+  BytecodeArrayBuilder builder(isolate(), zone());
+  builder.set_parameter_count(0);
+  builder.set_locals_count(0);
+
+  BytecodeLabel far0, far1, far2;
+  BytecodeLabel near0, near1, near2;
+
+  builder.Jump(&near0)
+      .JumpIfTrue(&near1)
+      .JumpIfFalse(&near2)
+      .Bind(&near0)
+      .Bind(&near1)
+      .Bind(&near2)
+      .Jump(&far0)
+      .JumpIfTrue(&far1)
+      .JumpIfFalse(&far2);
+  for (int i = 0; i < kFarJumpDistance - 6; i++) {
+    builder.LoadUndefined();
+  }
+  builder.Bind(&far0).Bind(&far1).Bind(&far2);
+  builder.Return();
+
+  Handle<BytecodeArray> array = builder.ToBytecodeArray();
+  DCHECK_EQ(array->length(), 12 + kFarJumpDistance - 6 + 1);
+
+  BytecodeArrayIterator iterator(array);
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 6);
+  iterator.Advance();
+
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 4);
+  iterator.Advance();
+
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 2);
+  iterator.Advance();
+
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpConstant);
+  CHECK_EQ(*iterator.GetConstantForIndexOperand(0),
+           Smi::FromInt(kFarJumpDistance));
+  CHECK_EQ(
+      array->get(iterator.current_offset() +
+                 Smi::cast(*iterator.GetConstantForIndexOperand(0))->value()),
+      Bytecodes::ToByte(Bytecode::kReturn));
+  iterator.Advance();
+
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrueConstant);
+  CHECK_EQ(*iterator.GetConstantForIndexOperand(0),
+           Smi::FromInt(kFarJumpDistance - 2));
+  CHECK_EQ(
+      array->get(iterator.current_offset() +
+                 Smi::cast(*iterator.GetConstantForIndexOperand(0))->value()),
+      Bytecodes::ToByte(Bytecode::kReturn));
+  iterator.Advance();
+
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalseConstant);
+  CHECK_EQ(*iterator.GetConstantForIndexOperand(0),
+           Smi::FromInt(kFarJumpDistance - 4));
+  CHECK_EQ(
+      array->get(iterator.current_offset() +
+                 Smi::cast(*iterator.GetConstantForIndexOperand(0))->value()),
+      Bytecodes::ToByte(Bytecode::kReturn));
+  iterator.Advance();
+}
+
+
+TEST_F(BytecodeArrayBuilderTest, BackwardJumps) {
+  BytecodeArrayBuilder builder(isolate(), zone());
+  builder.set_parameter_count(0);
+  builder.set_locals_count(0);
+
+  BytecodeLabel label0, label1, label2;
+  builder.Bind(&label0)
+      .Jump(&label0)
+      .Bind(&label1)
+      .JumpIfTrue(&label1)
+      .Bind(&label2)
+      .JumpIfFalse(&label2);
+  for (int i = 0; i < 64; i++) {
+    builder.Jump(&label2);
+  }
+  builder.JumpIfFalse(&label2);
+  builder.JumpIfTrue(&label1);
+  builder.Jump(&label0);
+  builder.Return();
+
+  Handle<BytecodeArray> array = builder.ToBytecodeArray();
+  BytecodeArrayIterator iterator(array);
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 0);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 0);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 0);
+  iterator.Advance();
+  for (int i = 0; i < 64; i++) {
+    CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+    CHECK_EQ(iterator.GetSmi8Operand(0), -i * 2 - 2);
+    iterator.Advance();
+  }
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalseConstant);
+  CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -130);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrueConstant);
+  CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -134);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpConstant);
+  CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -138);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
+  iterator.Advance();
+  CHECK(iterator.done());
+}
+
+
+TEST_F(BytecodeArrayBuilderTest, LabelReuse) {
+  BytecodeArrayBuilder builder(isolate(), zone());
+  builder.set_parameter_count(0);
+  builder.set_locals_count(0);
+
+  // Labels can only have 1 forward reference, but
+  // can be referred to mulitple times once bound.
+  BytecodeLabel label;
+
+  builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label).Return();
+
+  Handle<BytecodeArray> array = builder.ToBytecodeArray();
+  BytecodeArrayIterator iterator(array);
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 2);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+  CHECK_EQ(iterator.GetSmi8Operand(0), 0);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+  CHECK_EQ(iterator.GetSmi8Operand(0), -2);
+  iterator.Advance();
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
+  iterator.Advance();
+  CHECK(iterator.done());
+}
+
+
+TEST_F(BytecodeArrayBuilderTest, LabelAddressReuse) {
+  static const int kRepeats = 3;
+
+  BytecodeArrayBuilder builder(isolate(), zone());
+  builder.set_parameter_count(0);
+  builder.set_locals_count(0);
+
+  for (int i = 0; i < kRepeats; i++) {
+    BytecodeLabel label;
+    builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label);
+  }
+
+  builder.Return();
+
+  Handle<BytecodeArray> array = builder.ToBytecodeArray();
+  BytecodeArrayIterator iterator(array);
+  for (int i = 0; i < kRepeats; i++) {
+    CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+    CHECK_EQ(iterator.GetSmi8Operand(0), 2);
+    iterator.Advance();
+    CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+    CHECK_EQ(iterator.GetSmi8Operand(0), 0);
+    iterator.Advance();
+    CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
+    CHECK_EQ(iterator.GetSmi8Operand(0), -2);
+    iterator.Advance();
+  }
+  CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
+  iterator.Advance();
+  CHECK(iterator.done());
+}
+
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8