[Interpreter] Basic flow control.

src/interpreter/bytecode-generator.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-generator.h"
 
 #include <stack>
 
 #include "src/compiler.h"
 #include "src/objects.h"
@@ skipping 96 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
   Visit(stmt->expression());
 }
 
 
 void BytecodeGenerator::VisitEmptyStatement(EmptyStatement* stmt) {
-  UNIMPLEMENTED();
+  // For control-flow it could be useful to signal empty paths here.
 }
 
 
-void BytecodeGenerator::VisitIfStatement(IfStatement* stmt) { UNIMPLEMENTED(); }
+void BytecodeGenerator::VisitIfStatement(IfStatement* stmt) {
+  // TODO(oth): spot easy cases if (true/1/false/0)?
+  BytecodeLabel else_start, else_end;
+  Visit(stmt->condition());
+  // TODO(oth) This cast may need to be pushed down the evaluation stack
+  // when logical connectives are implemented, e.g. &&, ||, etc. Optimization

[Michael Starzinger, 2015/09/23 08:46:24]

I am not sure what this TODO refers to exactly, but I think the coercion is in
the correct position here. The evaluation order of [[ToBoolean]] coercions
within if-statements and and binary logical operators is fully specified.
Short-circuiting for example can provide uncoerced value of {c} for {a || b ||
c}. So in general the if-statement needs to coerce before testing.

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

Sorry about the wording here.

Basically, the goal would be that BytecodeArrayBuilder is more selective about
whether it emits the CastToBoolean bytecode. Specifically, if the previous
bytecode is in the same block and that bytecode would have put a boolean value
in the accumulator then CastToBoolean is not emitted.

Implemented this in patch set 16.

+  // opportunities too in bytecode-array-builder.cc.
+  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::VisitContinueStatement(ContinueStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
   UNIMPLEMENTED();
 }
@@ skipping 313 matching lines @@
       UNIMPLEMENTED();
       break;
     default:
       VisitArithmeticExpression(binop);
       break;
   }
 }
 
 
 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());
 }
 
 
 void BytecodeGenerator::VisitSpread(Spread* expr) { UNREACHABLE(); }
 
 
 void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
   UNREACHABLE();
 }
 
@@ skipping 34 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorICSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8