[Interpreter] Move ToBoolean elision in BytecodeGenerator.

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 "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-stubs.h"
@@ skipping 172 matching lines @@
 
   // Applies all recorded control-flow commands after the finally-block again.
   // This generates a dynamic dispatch on the token from the entry point.
   void ApplyDeferredCommands() {
     // The fall-through path is covered by the default case, hence +1 here.
     SwitchBuilder dispatch(builder(), static_cast<int>(deferred_.size() + 1));
     for (size_t i = 0; i < deferred_.size(); ++i) {
       Entry& entry = deferred_[i];
       builder()->LoadLiteral(Smi::FromInt(entry.token));
       builder()->CompareOperation(Token::EQ_STRICT, token_register_);
-      dispatch.Case(static_cast<int>(i));
+      dispatch.Case(ToBooleanMode::kAlreadyBoolean, static_cast<int>(i));
     }
     dispatch.DefaultAt(static_cast<int>(deferred_.size()));
     for (size_t i = 0; i < deferred_.size(); ++i) {
       Entry& entry = deferred_[i];
       dispatch.SetCaseTarget(static_cast<int>(i));
       builder()->LoadAccumulatorWithRegister(result_register_);
       execution_control()->PerformCommand(entry.command, entry.statement);
     }
     dispatch.SetCaseTarget(static_cast<int>(deferred_.size()));
   }
@@ skipping 200 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocationScope);
 };
 
 // Scoped base class for determining how the result of an expression will be
 // used.
 class BytecodeGenerator::ExpressionResultScope {
  public:
   ExpressionResultScope(BytecodeGenerator* generator, Expression::Context kind)
       : generator_(generator),
+        outer_(generator->execution_result()),
+        allocator_(generator),
         kind_(kind),
-        outer_(generator->execution_result()),
-        allocator_(generator) {
+        type_hint_(TypeHint::kAny) {
     generator_->set_execution_result(this);
   }
 
   virtual ~ExpressionResultScope() {
     generator_->set_execution_result(outer_);
   }
 
   bool IsEffect() const { return kind_ == Expression::kEffect; }
   bool IsValue() const { return kind_ == Expression::kValue; }
   bool IsTest() const { return kind_ == Expression::kTest; }
 
   TestResultScope* AsTest() {
     DCHECK(IsTest());
     return reinterpret_cast<TestResultScope*>(this);
   }
 
+  // Specify expression always returns a Boolean result value.
+  void SetResultIsBoolean() {
+    DCHECK(type_hint_ == TypeHint::kAny);
+    type_hint_ = TypeHint::kBoolean;
+  }
+
+  TypeHint type_hint() const { return type_hint_; }
+
  private:
   BytecodeGenerator* generator_;
-  Expression::Context kind_;
   ExpressionResultScope* outer_;
   RegisterAllocationScope allocator_;
+  Expression::Context kind_;
+  TypeHint type_hint_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpressionResultScope);
 };
 
 // Scoped class used when the result of the current expression is not
 // expected to produce a result.
 class BytecodeGenerator::EffectResultScope final
     : public ExpressionResultScope {
  public:
   explicit EffectResultScope(BytecodeGenerator* generator)
@@ skipping 18 matching lines @@
         then_labels_(then_labels),
         else_labels_(else_labels),
         fallthrough_(fallthrough),
         result_consumed_by_test_(false) {}
 
   // Used when code special cases for TestResultScope and consumes any
   // possible value by testing and jumping to a then/else label.
   void SetResultConsumedByTest() {
     result_consumed_by_test_ = true;
   }
-
-  bool ResultConsumedByTest() { return result_consumed_by_test_; }
+  bool result_consumed_by_test() { return result_consumed_by_test_; }
 
   BytecodeLabel* NewThenLabel() { return then_labels_->New(); }
   BytecodeLabel* NewElseLabel() { return else_labels_->New(); }
 
   BytecodeLabels* then_labels() const { return then_labels_; }
   BytecodeLabels* else_labels() const { return else_labels_; }
 
   TestFallthrough fallthrough() const { return fallthrough_; }
   TestFallthrough inverted_fallthrough() const {
     switch (fallthrough_) {
@@ skipping 299 matching lines @@
 
 void BytecodeGenerator::BuildIndexedJump(Register index, size_t start_index,
                                          size_t size,
                                          ZoneVector<BytecodeLabel>& targets) {
   // TODO(neis): Optimize this by using a proper jump table.
   DCHECK_LE(start_index + size, targets.size());
   for (size_t i = start_index; i < start_index + size; i++) {
     builder()
         ->LoadLiteral(Smi::FromInt(static_cast<int>(i)))
         .CompareOperation(Token::Value::EQ_STRICT, index)
-        .JumpIfTrue(&(targets[i]));
+        .JumpIfTrue(ToBooleanMode::kAlreadyBoolean, &(targets[i]));
   }
   BuildAbort(BailoutReason::kInvalidJumpTableIndex);
 }
 
 void BytecodeGenerator::VisitIterationHeader(IterationStatement* stmt,
                                              LoopBuilder* loop_builder) {
   // Recall that stmt->yield_count() is always zero inside ordinary
   // (i.e. non-generator) functions.
   if (stmt->suspend_count() == 0) {
     loop_builder->LoopHeader();
@@ skipping 13 matching lines @@
     }
 
     loop_builder->LoopHeader(&resume_points_in_loop);
 
     // If we are not resuming, fall through to loop body.
     // If we are resuming, perform state dispatch.
     BytecodeLabel not_resuming;
     builder()
         ->LoadLiteral(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting))
         .CompareOperation(Token::Value::EQ_STRICT, generator_state_)
-        .JumpIfTrue(&not_resuming);
+        .JumpIfTrue(ToBooleanMode::kAlreadyBoolean, &not_resuming);
     BuildIndexedJump(generator_state_, first_yield, stmt->suspend_count(),
                      generator_resume_points_);
     builder()->Bind(&not_resuming);
   }
 }
 
 void BytecodeGenerator::VisitGeneratorPrologue() {
   // The generator resume trampoline abuses the new.target register both to
   // indicate that this is a resume call and to pass in the generator object.
   // In ordinary calls, new.target is always undefined because generator
@@ skipping 293 matching lines @@
     if (clause->is_default()) {
       default_index = i;
       continue;
     }
 
     // Perform label comparison as if via '===' with tag.
     VisitForAccumulatorValue(clause->label());
     builder()->CompareOperation(
         Token::Value::EQ_STRICT, tag,
         feedback_index(clause->CompareOperationFeedbackSlot()));
-    switch_builder.Case(i);
+    switch_builder.Case(ToBooleanMode::kAlreadyBoolean, i);
   }
 
   if (default_index >= 0) {
     // Emit default jump if there is a default case.
     switch_builder.DefaultAt(default_index);
   } else {
     // Otherwise if we have reached here none of the cases matched, so jump to
     // the end.
     switch_builder.Break();
   }
@@ skipping 181 matching lines @@
 
   // Set up loop counter
   Register index = register_allocator()->NewRegister();
   builder()->LoadLiteral(Smi::kZero);
   builder()->StoreAccumulatorInRegister(index);
 
   // The loop
   VisitIterationHeader(stmt, &loop_builder);
   builder()->SetExpressionAsStatementPosition(stmt->each());
   builder()->ForInContinue(index, cache_length);
-  loop_builder.BreakIfFalse();
+  loop_builder.BreakIfFalse(ToBooleanMode::kAlreadyBoolean);
   FeedbackSlot slot = stmt->ForInFeedbackSlot();
   builder()->ForInNext(receiver, index, triple.Truncate(2),
                        feedback_index(slot));
   loop_builder.ContinueIfUndefined();
   VisitForInAssignment(stmt->each(), stmt->EachFeedbackSlot());
   VisitIterationBody(stmt, &loop_builder);
   builder()->ForInStep(index);
   builder()->StoreAccumulatorInRegister(index);
   loop_builder.JumpToHeader(loop_depth_);
   loop_builder.EndLoop();
   builder()->Bind(&subject_null_label);
   builder()->Bind(&subject_undefined_label);
 }
 
 void BytecodeGenerator::VisitForOfStatement(ForOfStatement* stmt) {
   LoopBuilder loop_builder(builder());
 
   builder()->SetExpressionAsStatementPosition(stmt->assign_iterator());
   VisitForEffect(stmt->assign_iterator());
 
   VisitIterationHeader(stmt, &loop_builder);
   builder()->SetExpressionAsStatementPosition(stmt->next_result());
   VisitForEffect(stmt->next_result());
-  VisitForAccumulatorValue(stmt->result_done());
-  loop_builder.BreakIfTrue();
+  TypeHint type_hint = VisitForAccumulatorValue(stmt->result_done());
+  loop_builder.BreakIfTrue(ToBooleanModeFromTypeHint(type_hint));
 
   VisitForEffect(stmt->assign_each());
   VisitIterationBody(stmt, &loop_builder);
   loop_builder.JumpToHeader(loop_depth_);
   loop_builder.EndLoop();
 }
 
 void BytecodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
   TryCatchBuilder try_control_builder(builder(), stmt->catch_prediction());
 
@@ skipping 172 matching lines @@
 
     if (property->is_static() && property->is_computed_name()) {
       // The static prototype property is read only. We handle the non computed
       // property name case in the parser. Since this is the only case where we
       // need to check for an own read only property we special case this so we
       // do not need to do this for every property.
       BytecodeLabel done;
       builder()
           ->LoadLiteral(ast_string_constants()->prototype_string())
           .CompareOperation(Token::Value::EQ_STRICT, key)
-          .JumpIfFalse(&done)
+          .JumpIfFalse(ToBooleanMode::kAlreadyBoolean, &done)
           .CallRuntime(Runtime::kThrowStaticPrototypeError)
           .Bind(&done);
     }
 
     VisitForRegisterValue(property->value(), value);
     VisitSetHomeObject(value, receiver, property);
 
     if (!attr_assigned) {
       builder()
           ->LoadLiteral(Smi::FromInt(DONT_ENUM))
@@ skipping 79 matching lines @@
     else_labels.Bind(builder());
     VisitForAccumulatorValue(expr->else_expression());
     builder()->Bind(&end_label);
   }
 }
 
 void BytecodeGenerator::VisitLiteral(Literal* expr) {
   if (!execution_result()->IsEffect()) {
     const AstValue* raw_value = expr->raw_value();
     builder()->LoadLiteral(raw_value);
+    if (raw_value->IsTrue() || raw_value->IsFalse()) {
+      execution_result()->SetResultIsBoolean();
+    }
   }
 }
 
 void BytecodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
   // Materialize a regular expression literal.
   builder()->CreateRegExpLiteral(
       expr->raw_pattern(), feedback_index(expr->literal_slot()), expr->flags());
 }
 
 void BytecodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
@@ skipping 768 matching lines @@
 
     // Now dispatch on resume mode.
 
     BytecodeLabel resume_with_next;
     BytecodeLabel resume_with_return;
     BytecodeLabel resume_with_throw;
 
     builder()
         ->LoadLiteral(Smi::FromInt(JSGeneratorObject::kNext))
         .CompareOperation(Token::EQ_STRICT, resume_mode)
-        .JumpIfTrue(&resume_with_next)
+        .JumpIfTrue(ToBooleanMode::kAlreadyBoolean, &resume_with_next)
         .LoadLiteral(Smi::FromInt(JSGeneratorObject::kThrow))
         .CompareOperation(Token::EQ_STRICT, resume_mode)
-        .JumpIfTrue(&resume_with_throw)
+        .JumpIfTrue(ToBooleanMode::kAlreadyBoolean, &resume_with_throw)
         .Jump(&resume_with_return);
 
     builder()->Bind(&resume_with_return);
     {
       if (expr->is_async_generator()) {
         // Async generator methods will produce the iter result object.
         builder()->LoadAccumulatorWithRegister(input);
         execution_control()->AsyncReturnAccumulator();
       } else {
         RegisterList args = register_allocator()->NewRegisterList(2);
@@ skipping 340 matching lines @@
     VisitForEffect(expr->expression());
   } else if (execution_result()->IsTest()) {
     TestResultScope* test_result = execution_result()->AsTest();
     // No actual logical negation happening, we just swap the control flow by
     // swapping the target labels and the fallthrough branch.
     VisitForTest(expr->expression(), test_result->else_labels(),
                  test_result->then_labels(),
                  test_result->inverted_fallthrough());
     test_result->SetResultConsumedByTest();
   } else {
-    VisitForAccumulatorValue(expr->expression());
-    builder()->LogicalNot();
+    TypeHint type_hint = VisitForAccumulatorValue(expr->expression());
+    builder()->LogicalNot(ToBooleanModeFromTypeHint(type_hint));
   }
+  // Always returns a boolean value.
+  execution_result()->SetResultIsBoolean();
 }
 
 void BytecodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::Value::NOT:
       VisitNot(expr);
       break;
     case Token::Value::TYPEOF:
       VisitTypeOf(expr);
       break;
@@ skipping 258 matching lines @@
     Register lhs = VisitForRegisterValue(expr->left());
     VisitForAccumulatorValue(expr->right());
     builder()->SetExpressionPosition(expr);
     FeedbackSlot slot = expr->CompareOperationFeedbackSlot();
     if (slot.IsInvalid()) {
       builder()->CompareOperation(expr->op(), lhs);
     } else {
       builder()->CompareOperation(expr->op(), lhs, feedback_index(slot));
     }
   }
+  // Always returns a boolean value.
+  execution_result()->SetResultIsBoolean();
 }
 
 void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
   // TODO(rmcilroy): Special case "x * 1.0" and "x * -1" which are generated for
   // +x and -x by the parser.
   Register lhs = VisitForRegisterValue(expr->left());
   VisitForAccumulatorValue(expr->right());
   FeedbackSlot slot = expr->BinaryOperationFeedbackSlot();
   builder()->SetExpressionPosition(expr);
   builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
@@ skipping 114 matching lines @@
                    test_result->else_labels(), test_result->fallthrough());
     }
     test_result->SetResultConsumedByTest();
   } else {
     if (left->ToBooleanIsTrue()) {
       VisitForAccumulatorValue(left);
     } else if (left->ToBooleanIsFalse()) {
       VisitForAccumulatorValue(right);
     } else {
       BytecodeLabel end_label;
-      VisitForAccumulatorValue(left);
-      builder()->JumpIfTrue(&end_label);
+      TypeHint type_hint = VisitForAccumulatorValue(left);
+      builder()->JumpIfTrue(ToBooleanModeFromTypeHint(type_hint), &end_label);
       VisitForAccumulatorValue(right);
       builder()->Bind(&end_label);
     }
   }
 }
 
 void BytecodeGenerator::VisitLogicalAndExpression(BinaryOperation* binop) {
   Expression* left = binop->left();
   Expression* right = binop->right();
 
@@ skipping 13 matching lines @@
                    test_result->else_labels(), test_result->fallthrough());
     }
     test_result->SetResultConsumedByTest();
   } else {
     if (left->ToBooleanIsFalse()) {
       VisitForAccumulatorValue(left);
     } else if (left->ToBooleanIsTrue()) {
       VisitForAccumulatorValue(right);
     } else {
       BytecodeLabel end_label;
-      VisitForAccumulatorValue(left);
-      builder()->JumpIfFalse(&end_label);
+      TypeHint type_hint = VisitForAccumulatorValue(left);
+      builder()->JumpIfFalse(ToBooleanModeFromTypeHint(type_hint), &end_label);
       VisitForAccumulatorValue(right);
       builder()->Bind(&end_label);
     }
   }
 }
 
 void BytecodeGenerator::VisitRewritableExpression(RewritableExpression* expr) {
   Visit(expr->expression());
 }
 
@@ skipping 199 matching lines @@
                                Context::CLOSURE_INDEX, 0,
                                BytecodeArrayBuilder::kImmutableSlot);
   } else {
     DCHECK(closure_scope()->is_function_scope() ||
            closure_scope()->is_module_scope());
     builder()->LoadAccumulatorWithRegister(Register::function_closure());
   }
 }
 
 // Visits the expression |expr| and places the result in the accumulator.
-void BytecodeGenerator::VisitForAccumulatorValue(Expression* expr) {
+BytecodeGenerator::TypeHint BytecodeGenerator::VisitForAccumulatorValue(
+    Expression* expr) {
   ValueResultScope accumulator_scope(this);
   Visit(expr);
+  return accumulator_scope.type_hint();
 }
 
 void BytecodeGenerator::VisitForAccumulatorValueOrTheHole(Expression* expr) {
   if (expr == nullptr) {
     builder()->LoadTheHole();
   } else {
     VisitForAccumulatorValue(expr);
   }
 }
 
@@ skipping 43 matching lines @@
   builder()->LoadUndefined().StoreAccumulatorInRegister(reg);
 }
 
 // Visits the expression |expr| for testing its boolean value and jumping to the
 // |then| or |other| label depending on value and short-circuit semantics
 void BytecodeGenerator::VisitForTest(Expression* expr,
                                      BytecodeLabels* then_labels,
                                      BytecodeLabels* else_labels,
                                      TestFallthrough fallthrough) {
   bool result_consumed;
+  TypeHint type_hint;
   {
     // To make sure that all temporary registers are returned before generating
     // jumps below, we ensure that the result scope is deleted before doing so.
     // Dead registers might be materialized otherwise.
     TestResultScope test_result(this, then_labels, else_labels, fallthrough);
     Visit(expr);
-    result_consumed = test_result.ResultConsumedByTest();
+    result_consumed = test_result.result_consumed_by_test();
+    type_hint = test_result.type_hint();
   }
   if (!result_consumed) {
+    ToBooleanMode mode(ToBooleanModeFromTypeHint(type_hint));
     switch (fallthrough) {
       case TestFallthrough::kThen:
-        builder()->JumpIfFalse(else_labels->New());
+        builder()->JumpIfFalse(mode, else_labels->New());
         break;
       case TestFallthrough::kElse:
-        builder()->JumpIfTrue(then_labels->New());
+        builder()->JumpIfTrue(mode, then_labels->New());
         break;
       case TestFallthrough::kNone:
-        builder()->JumpIfTrue(then_labels->New());
+        builder()->JumpIfTrue(mode, then_labels->New());
         builder()->Jump(else_labels->New());
     }
   }
 }
 
 void BytecodeGenerator::VisitInScope(Statement* stmt, Scope* scope) {
   DCHECK(scope->declarations()->is_empty());
   CurrentScope current_scope(this, scope);
   ContextScope context_scope(this, scope);
   Visit(stmt);
 }
 
+BytecodeArrayBuilder::ToBooleanMode
+BytecodeGenerator::ToBooleanModeFromTypeHint(TypeHint type_hint) {
+  return type_hint == TypeHint::kBoolean ? ToBooleanMode::kAlreadyBoolean
+                                         : ToBooleanMode::kConvertToBoolean;
+}
+
 LanguageMode BytecodeGenerator::language_mode() const {
   return current_scope()->language_mode();
 }
 
 int BytecodeGenerator::feedback_index(FeedbackSlot slot) const {
   return FeedbackVector::GetIndex(slot);
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreToSuper_Strict
                                     : Runtime::kStoreToSuper_Sloppy;
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8