[Interpreter] Move ToBoolean elision in BytecodeGenerator.

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"
 
 #include "src/globals.h"
 #include "src/interpreter/bytecode-array-writer.h"
 #include "src/interpreter/bytecode-dead-code-optimizer.h"
 #include "src/interpreter/bytecode-label.h"
@@ skipping 310 matching lines @@
                                                            int feedback_slot) {
   if (op == Token::Value::ADD) {
     OutputInc(feedback_slot);
   } else {
     DCHECK_EQ(op, Token::Value::SUB);
     OutputDec(feedback_slot);
   }
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::LogicalNot() {
-  OutputToBooleanLogicalNot();
+BytecodeArrayBuilder& BytecodeArrayBuilder::LogicalNot(ToBooleanMode mode) {
+  if (mode == ToBooleanMode::kAlreadyBoolean) {
+    OutputLogicalNot();
+  } else {
+    DCHECK_EQ(mode, ToBooleanMode::kConvertToBoolean);
+    OutputToBooleanLogicalNot();
+  }
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::TypeOf() {
   OutputTypeOf();
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::GetSuperConstructor(Register out) {
   OutputGetSuperConstructor(out);
@@ skipping 545 matching lines @@
   LeaveBasicBlock();
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Jump(BytecodeLabel* label) {
   DCHECK(!label->is_bound());
   OutputJump(label, 0);
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfTrue(BytecodeLabel* label) {
-  // The peephole optimizer attempts to simplify JumpIfToBooleanTrue
-  // to JumpIfTrue.
+BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfTrue(ToBooleanMode mode,
+                                                       BytecodeLabel* label) {
   DCHECK(!label->is_bound());
-  OutputJumpIfToBooleanTrue(label, 0);
+  if (mode == ToBooleanMode::kAlreadyBoolean) {
+    OutputJumpIfTrue(label, 0);
+  } else {
+    DCHECK_EQ(mode, ToBooleanMode::kConvertToBoolean);
+    OutputJumpIfToBooleanTrue(label, 0);
+  }
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfFalse(BytecodeLabel* label) {
+BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfFalse(ToBooleanMode mode,
+                                                        BytecodeLabel* label) {
   DCHECK(!label->is_bound());
-  OutputJumpIfToBooleanFalse(label, 0);
+  if (mode == ToBooleanMode::kAlreadyBoolean) {
+    OutputJumpIfFalse(label, 0);
+  } else {
+    DCHECK_EQ(mode, ToBooleanMode::kConvertToBoolean);
+    OutputJumpIfToBooleanFalse(label, 0);
+  }
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNull(BytecodeLabel* label) {
   DCHECK(!label->is_bound());
   OutputJumpIfNull(label, 0);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotNull(
@@ skipping 15 matching lines @@
   DCHECK(!label->is_bound());
   OutputJumpIfNotUndefined(label, 0);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNil(BytecodeLabel* label,
                                                       Token::Value op,
                                                       NilValue nil) {
   if (op == Token::EQ) {
     // TODO(rmcilroy): Implement JumpIfUndetectable.
-    return CompareUndetectable().JumpIfTrue(label);
+    return CompareUndetectable().JumpIfTrue(ToBooleanMode::kAlreadyBoolean,
+                                            label);
   } else {
     DCHECK_EQ(Token::EQ_STRICT, op);
     if (nil == kUndefinedValue) {
       return JumpIfUndefined(label);
     } else {
       DCHECK_EQ(kNullValue, nil);
       return JumpIfNull(label);
     }
   }
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotNil(BytecodeLabel* label,
                                                          Token::Value op,
                                                          NilValue nil) {
   if (op == Token::EQ) {
     // TODO(rmcilroy): Implement JumpIfUndetectable.
-    return CompareUndetectable().JumpIfFalse(label);
+    return CompareUndetectable().JumpIfFalse(ToBooleanMode::kAlreadyBoolean,
+                                             label);
   } else {
     DCHECK_EQ(Token::EQ_STRICT, op);
     if (nil == kUndefinedValue) {
       return JumpIfNotUndefined(label);
     } else {
       DCHECK_EQ(kNullValue, nil);
       return JumpIfNotNull(label);
     }
   }
 }
@@ skipping 349 matching lines @@
 }
 
 uint32_t BytecodeArrayBuilder::GetOutputRegisterListOperand(
     RegisterList reg_list) {
   DCHECK(RegisterListIsValid(reg_list));
   if (register_optimizer_)
     register_optimizer_->PrepareOutputRegisterList(reg_list);
   return static_cast<uint32_t>(reg_list.first_register().ToOperand());
 }
 
+std::ostream& operator<<(std::ostream& os,
+                         const BytecodeArrayBuilder::ToBooleanMode& mode) {
+  switch (mode) {
+    case BytecodeArrayBuilder::ToBooleanMode::kAlreadyBoolean:
+      return os << "AlreadyBoolean";
+    case BytecodeArrayBuilder::ToBooleanMode::kConvertToBoolean:
+      return os << "ConvertToBoolean";
+  }
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8