[Interpreter] Optimize code of the form 'if (x === undefined)'.

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"
@@ skipping 197 matching lines @@
   // Emit test operator invocations.
   builder.CompareOperation(Token::Value::EQ, reg, 1)
       .CompareOperation(Token::Value::EQ_STRICT, reg, 2)
       .CompareOperation(Token::Value::EQ_STRICT, reg)
       .CompareOperation(Token::Value::LT, reg, 3)
       .CompareOperation(Token::Value::GT, reg, 4)
       .CompareOperation(Token::Value::LTE, reg, 5)
       .CompareOperation(Token::Value::GTE, reg, 6)
       .CompareTypeOf(TestTypeOfFlags::LiteralFlag::kNumber)
       .CompareOperation(Token::Value::INSTANCEOF, reg)
-      .CompareOperation(Token::Value::IN, reg);
+      .CompareOperation(Token::Value::IN, reg)
+      .CompareUndetectable()
+      .CompareUndefined()
+      .CompareNull();
 
   // Emit peephole optimizations of equality with Null or Undefined.
   builder.LoadUndefined()
       .CompareOperation(Token::Value::EQ, reg, 1)
       .LoadNull()
       .CompareOperation(Token::Value::EQ, reg, 1)
       .LoadUndefined()
       .CompareOperation(Token::Value::EQ_STRICT, reg, 1)
       .LoadNull()
       .CompareOperation(Token::Value::EQ_STRICT, reg, 1);
 
   // Emit conversion operator invocations.
   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_jump5, after_jump6, after_jump7;
     builder.Bind(&start)
         .Jump(&after_jump1)
         .Bind(&after_jump1)
         .JumpIfNull(&after_jump2)
         .Bind(&after_jump2)
-        .JumpIfUndefined(&after_jump3)
+        .JumpIfNotNull(&after_jump3)
         .Bind(&after_jump3)
-        .JumpIfNotHole(&after_jump4)
+        .JumpIfUndefined(&after_jump4)
         .Bind(&after_jump4)
-        .JumpIfJSReceiver(&after_jump5)
+        .JumpIfNotUndefined(&after_jump5)
         .Bind(&after_jump5)
+        .JumpIfNotHole(&after_jump6)
+        .Bind(&after_jump6)
+        .JumpIfJSReceiver(&after_jump7)
+        .Bind(&after_jump7)
         .JumpLoop(&start, 0);
   }
 
   // Longer jumps with constant operands
-  BytecodeLabel end[9];
+  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])
         .JumpIfNull(&end[5])
-        .JumpIfUndefined(&end[6])
-        .JumpIfNotHole(&end[7])
+        .JumpIfNotNull(&end[6])
+        .JumpIfUndefined(&end[7])
+        .JumpIfNotUndefined(&end[8])
+        .JumpIfNotHole(&end[9])
         .LoadLiteral(ast_factory.prototype_string())
-        .JumpIfJSReceiver(&end[8]);
+        .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)
@@ skipping 150 matching lines @@
     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;
-    scorecard[Bytecodes::ToByte(Bytecode::kTestUndetectable)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kTestUndefined)] = 1;
-    scorecard[Bytecodes::ToByte(Bytecode::kTestNull)] = 1;
   }
 
   if (!FLAG_type_profile) {
     // Bytecode for CollectTypeProfile is only emitted when
     // Type Information for DevTools is turned on.
     scorecard[Bytecodes::ToByte(Bytecode::kCollectTypeProfile)] = 1;
   }
 
   // Check return occurs at the end and only once in the BytecodeArray.
   CHECK_EQ(final_bytecode, Bytecode::kReturn);
@@ skipping 330 matching lines @@
     iterator.Advance();
   }
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
   iterator.Advance();
   CHECK(iterator.done());
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8