[builtins] implement Array.prototype.includes in TurboFan

src/code-stub-assembler.cc

 // Copyright 2016 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-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/stub-cache.h"
 
@@ skipping 453 matching lines @@
 
 Node* CodeStubAssembler::WordIsSmi(Node* a) {
   return WordEqual(WordAnd(a, IntPtrConstant(kSmiTagMask)), IntPtrConstant(0));
 }
 
 Node* CodeStubAssembler::WordIsPositiveSmi(Node* a) {
   return WordEqual(WordAnd(a, IntPtrConstant(kSmiTagMask | kSmiSignMask)),
                    IntPtrConstant(0));
 }
 
+void CodeStubAssembler::BranchIfSameValueZero(Node* a, Node* b, Node* context,
+                                              Label* if_true, Label* if_false) {
+  Label if_noteq(this), if_a_isnan(this);
+  Node* heap_number_type = Int32Constant(HEAP_NUMBER_TYPE);
+  BranchIf(CallRuntime(Runtime::kInlineStrictEqual, context, a, b), if_true,

[caitp, 2016/07/15 17:24:35]

this was the problem --- fixing this made the perf results a lot worse, so I
implemented a more proper SameValueZero here in the next patchset.

The spec does not say anything about SameValueZero equating SIMD objects, so I'm
not sure if it should or not. At the moment, it doesn't.

Another option is to just call the StrictEquals stub and then fix the NaN stuff
after, but that's probably still a slow path.

With the change, the fast path is significantly faster, but not as fast as it
could be maybe.

+           &if_noteq);
+
+  Bind(&if_noteq);
+  GotoIf(WordIsSmi(a), if_false);
+
+  Node* a_type = LoadInstanceType(a);
+  GotoIf(WordNotEqual(a_type, heap_number_type), if_false);
+
+  Node* a_value = LoadHeapNumberValue(a);
+  BranchIfFloat64IsNaN(a_value, &if_a_isnan, if_false);
+
+  Bind(&if_a_isnan);
+  GotoIf(WordIsSmi(b), if_false);
+
+  Node* b_type = LoadInstanceType(b);
+  GotoIf(WordNotEqual(b_type, heap_number_type), if_false);
+
+  Node* b_value = LoadHeapNumberValue(b);
+  BranchIfFloat64IsNaN(b_value, if_true, if_false);
+}
+
 Node* CodeStubAssembler::AllocateRawUnaligned(Node* size_in_bytes,
                                               AllocationFlags flags,
                                               Node* top_address,
                                               Node* limit_address) {
   Node* top = Load(MachineType::Pointer(), top_address);
   Node* limit = Load(MachineType::Pointer(), limit_address);
 
   // If there's not enough space, call the runtime.
   Variable result(this, MachineRepresentation::kTagged);
   Label runtime_call(this, Label::kDeferred), no_runtime_call(this);
@@ skipping 2506 matching lines @@
   }
   Bind(&miss);
   {
     TailCallRuntime(Runtime::kLoadGlobalIC_Miss, p->context, p->slot,
                     p->vector);
   }
 }
 
 }  // namespace internal
 }  // namespace v8