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

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 371 matching lines @@
       break;
     case Token::Value::IN:
       OutputTestIn(reg);
       break;
     default:
       UNREACHABLE();
   }
   return *this;
 }
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::CompareUndetectable() {
+  OutputTestUndetectable();
+  return *this;
+}
+
+BytecodeArrayBuilder& BytecodeArrayBuilder::CompareUndefined() {
+  OutputTestUndefined();
+  return *this;
+}
+
+BytecodeArrayBuilder& BytecodeArrayBuilder::CompareNull() {
+  OutputTestNull();
+  return *this;
+}
+
+BytecodeArrayBuilder& BytecodeArrayBuilder::CompareNil(Token::Value op,
+                                                       NilValue nil) {
+  if (op == Token::EQ) {
+    return CompareUndetectable();
+  } else {
+    DCHECK_EQ(Token::EQ_STRICT, op);
+    if (nil == kUndefinedValue) {
+      return CompareUndefined();
+    } else {
+      DCHECK_EQ(kNullValue, nil);
+      return CompareNull();
+    }
+  }
+}
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::CompareTypeOf(
     TestTypeOfFlags::LiteralFlag literal_flag) {
   DCHECK(literal_flag != TestTypeOfFlags::LiteralFlag::kOther);
   OutputTestTypeOf(TestTypeOfFlags::Encode(literal_flag));
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadConstantPoolEntry(
     size_t entry) {
   OutputLdaConstant(entry);
@@ skipping 476 matching lines @@
   OutputJumpIfToBooleanFalse(label, 0);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNull(BytecodeLabel* label) {
   DCHECK(!label->is_bound());
   OutputJumpIfNull(label, 0);
   return *this;
 }
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotNull(
+    BytecodeLabel* label) {
+  DCHECK(!label->is_bound());
+  OutputJumpIfNotNull(label, 0);
+  return *this;
+}
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfUndefined(
     BytecodeLabel* label) {
   DCHECK(!label->is_bound());
   OutputJumpIfUndefined(label, 0);
   return *this;
 }
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotUndefined(
+    BytecodeLabel* label) {
+  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);
+  } 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);
+  } else {
+    DCHECK_EQ(Token::EQ_STRICT, op);
+    if (nil == kUndefinedValue) {
+      return JumpIfNotUndefined(label);
+    } else {
+      DCHECK_EQ(kNullValue, nil);
+      return JumpIfNotNull(label);
+    }
+  }
+}
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotHole(
     BytecodeLabel* label) {
   DCHECK(!label->is_bound());
   OutputJumpIfNotHole(label, 0);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfJSReceiver(
     BytecodeLabel* label) {
   DCHECK(!label->is_bound());
@@ skipping 341 matching lines @@
     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());
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8