[Interpreter] Move ToBoolean elision in BytecodeGenerator.

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

 // Copyright 2014 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/v8.h"
 
 #include "src/ast/scopes.h"
 #include "src/interpreter/bytecode-array-builder.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-label.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/objects-inl.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class BytecodeArrayBuilderTest : public TestWithIsolateAndZone {
  public:
   BytecodeArrayBuilderTest() {}
   ~BytecodeArrayBuilderTest() override {}
 };
 
+using ToBooleanMode = BytecodeArrayBuilder::ToBooleanMode;
+
 TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
   CanonicalHandleScope canonical(isolate());
   BytecodeArrayBuilder builder(isolate(), zone(), 0, 1, 131);
   Factory* factory = isolate()->factory();
   AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
                               isolate()->heap()->HashSeed());
   DeclarationScope scope(zone(), &ast_factory);
 
   CHECK_EQ(builder.locals_count(), 131);
   CHECK_EQ(builder.context_count(), 1);
@@ skipping 153 matching lines @@
       .BinaryOperation(Token::Value::SHL, reg, 5)
       .LoadLiteral(Smi::FromInt(6))
       .BinaryOperation(Token::Value::SAR, reg, 6);
 
   // Emit count operatior invocations
   builder.CountOperation(Token::Value::ADD, 1)
       .CountOperation(Token::Value::SUB, 1);
 
   // Emit unary operator invocations.
   builder
-      .LogicalNot()  // ToBooleanLogicalNot
-      .LogicalNot()  // non-ToBoolean LogicalNot
+      .LogicalNot(ToBooleanMode::kConvertToBoolean)
+      .LogicalNot(ToBooleanMode::kAlreadyBoolean)
       .TypeOf();
 
   // Emit delete
   builder.Delete(reg, LanguageMode::SLOPPY).Delete(reg, LanguageMode::STRICT);
 
   // Emit construct.
   builder.Construct(reg, reg_list, 1).ConstructWithSpread(reg, reg_list);
 
   // Emit test operator invocations.
   builder.CompareOperation(Token::Value::EQ, reg, 1)
@@ skipping 24 matching lines @@
   builder.ConvertAccumulatorToNumber(reg)
       .ConvertAccumulatorToObject(reg)
       .ConvertAccumulatorToName(reg);
 
   // Emit GetSuperConstructor.
   builder.GetSuperConstructor(reg);
 
   // Short jumps with Imm8 operands
   {
     BytecodeLabel start, after_jump1, after_jump2, after_jump3, after_jump4,
-        after_jump5, after_jump6, after_jump7;
+        after_jump5, after_jump6, after_jump7, after_jump8, after_jump9,
+        after_jump10, after_jump11;
     builder.Bind(&start)
         .Jump(&after_jump1)
         .Bind(&after_jump1)
         .JumpIfNull(&after_jump2)
         .Bind(&after_jump2)
         .JumpIfNotNull(&after_jump3)
         .Bind(&after_jump3)
         .JumpIfUndefined(&after_jump4)
         .Bind(&after_jump4)
         .JumpIfNotUndefined(&after_jump5)
         .Bind(&after_jump5)
         .JumpIfNotHole(&after_jump6)
         .Bind(&after_jump6)
         .JumpIfJSReceiver(&after_jump7)
         .Bind(&after_jump7)
+        .JumpIfTrue(ToBoolean::kConvertToBoolean, &after_jump8)
+        .Bind(&after_jump8)
+        .JumpIfTrue(ToBoolean::kAlreadyBoolean, &after_jump9)
+        .Bind(&after_jump9)
+        .JumpIfFalse(ToBoolean::kConvertToBoolean, &after_jump10)
+        .Bind(&after_jump10)
+        .JumpIfFalse(ToBoolean::kAlreadyBoolean, &after_jump11)
+        .Bind(&after_jump11)
         .JumpLoop(&start, 0);
   }
 
   // Longer jumps with constant operands
   BytecodeLabel end[11];
   {
     BytecodeLabel after_jump;
     builder.Jump(&end[0])
         .Bind(&after_jump)
-        .LoadTrue()
-        .JumpIfTrue(&end[1])
-        .LoadTrue()
-        .JumpIfFalse(&end[2])
-        .LoadLiteral(Smi::kZero)
-        .JumpIfTrue(&end[3])
-        .LoadLiteral(Smi::kZero)
-        .JumpIfFalse(&end[4])
+        .JumpIfTrue(ToBoolean::kConvertToBoolean, &end[1])
+        .JumpIfTrue(ToBoolean::kAlreadyBoolean, &end[2])
+        .JumpIfFalse(ToBoolean::kConvertToBoolean, &end[3])
+        .JumpIfFalse(ToBoolean::kAlreadyBoolean, &end[4])
         .JumpIfNull(&end[5])
         .JumpIfNotNull(&end[6])
         .JumpIfUndefined(&end[7])
         .JumpIfNotUndefined(&end[8])
         .JumpIfNotHole(&end[9])
         .LoadLiteral(ast_factory.prototype_string())
         .JumpIfJSReceiver(&end[10]);
   }
 
-  // Perform an operation that returns boolean value to
-  // generate JumpIfTrue/False
-  {
-    BytecodeLabel after_jump1, after_jump2;
-    builder.CompareOperation(Token::Value::EQ, reg, 1)
-        .JumpIfTrue(&after_jump1)
-        .Bind(&after_jump1)
-        .CompareOperation(Token::Value::EQ, reg, 2)
-        .JumpIfFalse(&after_jump2)
-        .Bind(&after_jump2);
-  }
-
-  // Perform an operation that returns a non-boolean operation to
-  // generate JumpIfToBooleanTrue/False.
-  {
-    BytecodeLabel after_jump1, after_jump2;
-    builder.BinaryOperation(Token::Value::ADD, reg, 1)
-        .JumpIfTrue(&after_jump1)
-        .Bind(&after_jump1)
-        .BinaryOperation(Token::Value::ADD, reg, 2)
-        .JumpIfFalse(&after_jump2)
-        .Bind(&after_jump2);
-  }
-
   // Emit set pending message bytecode.
   builder.SetPendingMessage();
 
   // Emit stack check bytecode.
   builder.StackCheck(0);
 
   // Emit throw and re-throw in it's own basic block so that the rest of the
   // code isn't omitted due to being dead.
   BytecodeLabel after_throw;
   builder.Throw().Bind(&after_throw);
@@ skipping 112 matching lines @@
   }
 
   // Insert entry for illegal bytecode as this is never willingly emitted.
   scorecard[Bytecodes::ToByte(Bytecode::kIllegal)] = 1;
 
   // Insert entry for nop bytecode as this often gets optimized out.
   scorecard[Bytecodes::ToByte(Bytecode::kNop)] = 1;
 
   if (!FLAG_ignition_peephole) {
     // Insert entries for bytecodes only emitted by peephole optimizer.
-    scorecard[Bytecodes::ToByte(Bytecode::kLogicalNot)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kJump)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kJumpIfTrue)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kJumpIfFalse)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kJumpIfTrueConstant)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kJumpIfFalseConstant)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kAddSmi)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kSubSmi)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kBitwiseAndSmi)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kBitwiseOrSmi)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kShiftLeftSmi)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kShiftRightSmi)] = 1;
   }
 
   if (!FLAG_type_profile) {
     // Bytecode for CollectTypeProfile is only emitted when
@@ skipping 336 matching lines @@
     iterator.Advance();
   }
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
   iterator.Advance();
   CHECK(iterator.done());
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8