[builtins] implement Array.prototype.includes in TurboFan

src/code-stubs.cc

 // Copyright 2012 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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/factory.h"
 #include "src/gdb-jit.h"
 #include "src/ic/handler-compiler.h"
 #include "src/ic/ic.h"
 #include "src/macro-assembler.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
 namespace internal {
 
+enum class StrictEqualsFlags : unsigned char {
+  Normal = 0,
+  NanEqualsNan = 1 << 0,
+};
+
+static inline bool operator&(StrictEqualsFlags lhs, StrictEqualsFlags rhs) {
+  return (static_cast<unsigned char>(lhs) & static_cast<unsigned char>(rhs)) !=
+         0;
+}
 
 RUNTIME_FUNCTION(UnexpectedStubMiss) {
   FATAL("Unexpected deopt of a stub");
   return Smi::FromInt(0);
 }
 
 
 CodeStubDescriptor::CodeStubDescriptor(CodeStub* stub)
     : call_descriptor_(stub->GetCallInterfaceDescriptor()),
       stack_parameter_count_(no_reg),
@@ skipping 2227 matching lines @@
   }
 
   assembler->Bind(&end);
   return result.value();
 }
 
 enum ResultMode { kDontNegateResult, kNegateResult };
 
 void GenerateEqual_Same(CodeStubAssembler* assembler, compiler::Node* value,
                         CodeStubAssembler::Label* if_equal,
-                        CodeStubAssembler::Label* if_notequal) {
+                        CodeStubAssembler::Label* if_notequal,
+                        StrictEqualsFlags flags) {
   // In case of abstract or strict equality checks, we need additional checks
   // for NaN values because they are not considered equal, even if both the
   // left and the right hand side reference exactly the same value.
   // TODO(bmeurer): This seems to violate the SIMD.js specification, but it
   // seems to be what is tested in the current SIMD.js testsuite.
 
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   // Check if {value} is a Smi or a HeapObject.
   Label if_valueissmi(assembler), if_valueisnotsmi(assembler);
   assembler->Branch(assembler->WordIsSmi(value), &if_valueissmi,
                     &if_valueisnotsmi);
 
   assembler->Bind(&if_valueisnotsmi);
   {
     // Load the map of {value}.
     Node* value_map = assembler->LoadMap(value);
 
     // Check if {value} (and therefore {rhs}) is a HeapNumber.
     Node* number_map = assembler->HeapNumberMapConstant();
     Label if_valueisnumber(assembler), if_valueisnotnumber(assembler);
     assembler->Branch(assembler->WordEqual(value_map, number_map),
                       &if_valueisnumber, &if_valueisnotnumber);
 
     assembler->Bind(&if_valueisnumber);
     {
-      // Convert {value} (and therefore {rhs}) to floating point value.
-      Node* value_value = assembler->LoadHeapNumberValue(value);
+      if (flags & StrictEqualsFlags::NanEqualsNan) {
+        // NaN === NaN --- No special treatment
+        assembler->Goto(if_equal);
+      } else {
+        // Convert {value} (and therefore {rhs}) to floating point value.
+        Node* value_value = assembler->LoadHeapNumberValue(value);
 
-      // Check if the HeapNumber value is a NaN.
-      assembler->BranchIfFloat64IsNaN(value_value, if_notequal, if_equal);
+        // Check if the HeapNumber value is a NaN.
+        assembler->BranchIfFloat64IsNaN(value_value, if_notequal, if_equal);
+      }
     }
 
     assembler->Bind(&if_valueisnotnumber);
     assembler->Goto(if_equal);
   }
 
   assembler->Bind(&if_valueissmi);
   assembler->Goto(if_equal);
 }
 
@@ skipping 112 matching lines @@
     rhs = var_rhs.value();
 
     // Check if {lhs} and {rhs} refer to the same object.
     Label if_same(assembler), if_notsame(assembler);
     assembler->Branch(assembler->WordEqual(lhs, rhs), &if_same, &if_notsame);
 
     assembler->Bind(&if_same);
     {
       // The {lhs} and {rhs} reference the exact same value, yet we need special
       // treatment for HeapNumber, as NaN is not equal to NaN.
-      GenerateEqual_Same(assembler, lhs, &if_equal, &if_notequal);
+      GenerateEqual_Same(assembler, lhs, &if_equal, &if_notequal,
+                         StrictEqualsFlags::Normal);
     }
 
     assembler->Bind(&if_notsame);
     {
       // Check if {lhs} is a Smi or a HeapObject.
       Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler);
       assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi,
                         &if_lhsisnotsmi);
 
       assembler->Bind(&if_lhsissmi);
@@ skipping 479 matching lines @@
     assembler->Goto(&end);
   }
 
   assembler->Bind(&end);
   return result.value();
 }
 
 compiler::Node* GenerateStrictEqual(CodeStubAssembler* assembler,
                                     ResultMode mode, compiler::Node* lhs,
                                     compiler::Node* rhs,
-                                    compiler::Node* context) {
+                                    compiler::Node* context,
+                                    StrictEqualsFlags flags) {
   // Here's pseudo-code for the algorithm below in case of kDontNegateResult
   // mode; for kNegateResult mode we properly negate the result.
   //
   // if (lhs == rhs) {
   //   if (lhs->IsHeapNumber()) return HeapNumber::cast(lhs)->value() != NaN;
   //   return true;
   // }
   // if (!lhs->IsSmi()) {
   //   if (lhs->IsHeapNumber()) {
   //     if (rhs->IsSmi()) {
@@ skipping 43 matching lines @@
   Variable result(assembler, MachineRepresentation::kTagged);
 
   // Check if {lhs} and {rhs} refer to the same object.
   Label if_same(assembler), if_notsame(assembler);
   assembler->Branch(assembler->WordEqual(lhs, rhs), &if_same, &if_notsame);
 
   assembler->Bind(&if_same);
   {
     // The {lhs} and {rhs} reference the exact same value, yet we need special
     // treatment for HeapNumber, as NaN is not equal to NaN.
-    GenerateEqual_Same(assembler, lhs, &if_equal, &if_notequal);
+    GenerateEqual_Same(assembler, lhs, &if_equal, &if_notequal, flags);
   }
 
   assembler->Bind(&if_notsame);
   {
     // The {lhs} and {rhs} reference different objects, yet for Smi, HeapNumber,
     // String and Simd128Value they can still be considered equal.
     Node* number_map = assembler->HeapNumberMapConstant();
 
     // Check if {lhs} is a Smi or a HeapObject.
     Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler);
@@ skipping 36 matching lines @@
           Label if_rhsisnumber(assembler), if_rhsisnotnumber(assembler);
           assembler->Branch(assembler->WordEqual(rhs_map, number_map),
                             &if_rhsisnumber, &if_rhsisnotnumber);
 
           assembler->Bind(&if_rhsisnumber);
           {
             // Convert {lhs} and {rhs} to floating point values.
             Node* lhs_value = assembler->LoadHeapNumberValue(lhs);
             Node* rhs_value = assembler->LoadHeapNumberValue(rhs);
 
+            if (flags & StrictEqualsFlags::NanEqualsNan) {
+              Label isnan(assembler), isnotnan(assembler);
+              assembler->BranchIfFloat64IsNaN(lhs_value, &isnan, &isnotnan);
+
+              assembler->Bind(&isnan);
+              assembler->BranchIfFloat64IsNaN(rhs_value, &if_equal, &isnotnan);
+
+              assembler->Bind(&isnotnan);
+            }
+
             // Perform a floating point comparison of {lhs} and {rhs}.
             assembler->BranchIfFloat64Equal(lhs_value, rhs_value, &if_equal,
                                             &if_notequal);
           }
 
           assembler->Bind(&if_rhsisnotnumber);
           assembler->Goto(&if_notequal);
         }
       }
 
@@ skipping 555 matching lines @@
                                        compiler::Node* lhs, compiler::Node* rhs,
                                        compiler::Node* context) {
   return GenerateEqual(assembler, kNegateResult, lhs, rhs, context);
 }
 
 // static
 compiler::Node* StrictEqualStub::Generate(CodeStubAssembler* assembler,
                                           compiler::Node* lhs,
                                           compiler::Node* rhs,
                                           compiler::Node* context) {
-  return GenerateStrictEqual(assembler, kDontNegateResult, lhs, rhs, context);
+  return GenerateStrictEqual(assembler, kDontNegateResult, lhs, rhs, context,
+                             StrictEqualsFlags::Normal);
 }
 
 // static
 compiler::Node* StrictNotEqualStub::Generate(CodeStubAssembler* assembler,
                                              compiler::Node* lhs,
                                              compiler::Node* rhs,
                                              compiler::Node* context) {
-  return GenerateStrictEqual(assembler, kNegateResult, lhs, rhs, context);
+  return GenerateStrictEqual(assembler, kNegateResult, lhs, rhs, context,
+                             StrictEqualsFlags::Normal);
+}
+
+compiler::Node* SameValueZeroStub::Generate(CodeStubAssembler* assembler,
+                                            compiler::Node* lhs,
+                                            compiler::Node* rhs,
+                                            compiler::Node* context) {
+  return GenerateStrictEqual(assembler, kDontNegateResult, lhs, rhs, context,
+                             StrictEqualsFlags::NanEqualsNan);
 }
 
 void StringEqualStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   GenerateStringEqual(assembler, kDontNegateResult);
 }
 
 void StringNotEqualStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   GenerateStringEqual(assembler, kNegateResult);
 }
 
@@ skipping 1287 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8