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

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 3022 matching lines @@
       break;
     case Token::AND:
       VisitLogicalAndExpression(binop);
       break;
     default:
       VisitArithmeticExpression(binop);
       break;
   }
 }
 
+void BytecodeGenerator::BuildLiteralCompareNil(Token::Value op, NilValue nil) {
+  if (execution_result()->IsTest()) {
+    TestResultScope* test_result = execution_result()->AsTest();
+    switch (test_result->fallthrough()) {
+      case TestFallthrough::kThen:
+        builder()->JumpIfNotNil(test_result->NewElseLabel(), op, nil);
+        break;
+      case TestFallthrough::kElse:
+        builder()->JumpIfNil(test_result->NewThenLabel(), op, nil);
+        break;
+      case TestFallthrough::kNone:
+        builder()
+            ->JumpIfNil(test_result->NewThenLabel(), op, nil)
+            .Jump(test_result->NewElseLabel());
+    }
+    test_result->SetResultConsumedByTest();
+  } else {
+    builder()->CompareNil(op, nil);
+  }
+}
+
 void BytecodeGenerator::VisitCompareOperation(CompareOperation* expr) {
-  // Emit a fast literal comparion for expressions of the form:
-  // typeof(x) === 'string'.
-  Expression* typeof_sub_expr;
+  Expression* sub_expr;
   Literal* literal;
-  if (expr->IsLiteralCompareTypeof(&typeof_sub_expr, &literal)) {
-    VisitForTypeOfValue(typeof_sub_expr);
+  if (expr->IsLiteralCompareTypeof(&sub_expr, &literal)) {
+    // Emit a fast literal comparion for expressions of the form:
+    // typeof(x) === 'string'.
+    VisitForTypeOfValue(sub_expr);
     builder()->SetExpressionPosition(expr);
     TestTypeOfFlags::LiteralFlag literal_flag =
         TestTypeOfFlags::GetFlagForLiteral(ast_string_constants(), literal);
     if (literal_flag == TestTypeOfFlags::LiteralFlag::kOther) {
       builder()->LoadFalse();
     } else {
       builder()->CompareTypeOf(literal_flag);
     }
+  } else if (expr->IsLiteralCompareUndefined(&sub_expr)) {
+    VisitForAccumulatorValue(sub_expr);
+    builder()->SetExpressionPosition(expr);
+    BuildLiteralCompareNil(expr->op(), kUndefinedValue);
+  } else if (expr->IsLiteralCompareNull(&sub_expr)) {
+    VisitForAccumulatorValue(sub_expr);
+    builder()->SetExpressionPosition(expr);
+    BuildLiteralCompareNil(expr->op(), kNullValue);
   } else {
     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));
     }
@@ skipping 498 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8