[Interpreter] Basic flow control.

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 "src/code-factory.h"
 #include "src/compiler.h"
 #include "src/compiler/interpreter-assembler.h"
 #include "src/factory.h"
@@ skipping 264 matching lines @@
   // operations, instead of calling builtins directly.
   Node* reg_index = __ BytecodeOperandReg(0);
   Node* lhs = __ LoadRegister(reg_index);
   Node* rhs = __ GetAccumulator();
   Node* result = __ CallRuntime(function_id, lhs, rhs);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 
+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.
 void Interpreter::DoAdd(compiler::InterpreterAssembler* assembler) {
   DoBinaryOp(Runtime::kAdd, assembler);
 }
 
 
 // Sub <src>
 //
@@ skipping 36 matching lines @@
   Node* function = __ LoadRegister(function_reg);
   Node* receiver_reg = __ BytecodeOperandReg(1);
   Node* first_arg = __ RegisterLocation(receiver_reg);
   Node* args_count = __ BytecodeOperandCount(2);
   Node* result = __ CallJS(function, first_arg, args_count);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 
+// TestEqual <src>
+//
+// Test if register equals the accumulator.

[rmcilroy, 2015/09/18 10:42:24]

nit (for all comments) - /s/Test if register/Test if value in <src> register

[oth, 2015/09/23 10:46:56]

Done.

+void Interpreter::DoTestEqual(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::EQ, assembler);
+}
+
+
+// TestNotEqual <src>
+//
+// Test if register not equal to the accumulator.
+void Interpreter::DoTestNotEqual(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::NE, assembler);
+}
+
+
+// TestEqualStrict <src>
+//
+// Test if register strictly equal to the accumulator.

[rmcilroy, 2015/09/18 10:42:24]

/s/strictly/is strictly (and below)

[oth, 2015/09/23 10:46:56]

Done.

+void Interpreter::DoTestEqualStrict(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::EQ_STRICT, assembler);
+}
+
+
+// TestNotEqualStrict <src>
+//
+// Test if register not strictly equal to the accumulator.
+void Interpreter::DoTestNotEqualStrict(
+    compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::NE_STRICT, assembler);
+}
+
+
+// TestLessThan <src>
+//
+// Test if register is less than the accumulator.
+void Interpreter::DoTestLessThan(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::LT, assembler);
+}
+
+
+// TestGreaterThan <src>
+//
+// Test if register is greater than the accumulator.
+void Interpreter::DoTestGreaterThan(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::GT, assembler);
+}
+
+
+// TestLessThanEqual <src>
+//
+// Test if register is less than or equal to the accumulator.
+void Interpreter::DoTestLessThanEqual(
+    compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::LTE, assembler);
+}
+
+
+// TestGreaterThanEqual <src>
+//
+// Test if register is greater than or equal to the accumulator.
+void Interpreter::DoTestGreaterThanEqual(
+    compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::GTE, assembler);
+}
+
+
+// TestIn <src>
+//
+// Test if register is in the collection referenced by the accumulator.
+void Interpreter::DoTestIn(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::IN, assembler);
+}
+
+
+// TestInstanceOf <src>
+//
+// Test if object referenced by register is an an instance of type referenced
+// by the accumulator.
+void Interpreter::DoTestInstanceOf(compiler::InterpreterAssembler* assembler) {
+  DoCompareOp(Token::Value::INSTANCEOF, assembler);
+}
+
+
+// JumpSmi8 <imm8>
+//
+// Jump by number of bytes represented by an immediate operand.
+void Interpreter::DoJumpSmi8(compiler::InterpreterAssembler* assembler) {
+  Node* int_value = __ BytecodeOperandImm8(0);

[rmcilroy, 2015/09/18 10:42:24]

nit - /s/int_value/jump_delta (and below)

[oth, 2015/09/23 10:46:56]

Done. s/int_value/relative_jump/ to match code further on.

+  __ Jump(int_value);
+}
+
+
+// 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* int_value = __ SmiUntag(constant);
+  __ Jump(int_value);
+}
+
+
+// JumpIfTrueSmi8 <imm8>
+//
+// Jump by number of bytes represented by an immediate operand if the
+// accumulator contains true.
+void Interpreter::DoJumpIfTrueSmi8(compiler::InterpreterAssembler* assembler) {
+  Node* accumulator = __ GetAccumulator();
+  Node* relative_jump = __ BytecodeOperandImm8(0);
+  Node* boolean_value = __ BooleanConstant(true);
+  __ JumpIfEqual(accumulator, boolean_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* boolean_value = __ BooleanConstant(true);
+  __ JumpIfEqual(accumulator, boolean_value, relative_jump);
+}
+
+
+// JumpIfFalseSmi8 <imm8>
+//
+// Jump by number of bytes represented by an immediate operand if the
+// accumulator contains false.
+void Interpreter::DoJumpIfFalseSmi8(compiler::InterpreterAssembler* assembler) {
+  Node* accumulator = __ GetAccumulator();
+  Node* relative_jump = __ BytecodeOperandImm8(0);
+  Node* boolean_value = __ BooleanConstant(false);
+  __ JumpIfEqual(accumulator, boolean_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* boolean_value = __ BooleanConstant(false);
+  __ JumpIfEqual(accumulator, boolean_value, relative_jump);
+}
+
+
 // Return
 //
 // Return the value in register 0.
 void Interpreter::DoReturn(compiler::InterpreterAssembler* assembler) {
   __ Return();
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8