[builtins] Array.prototype.filter implemented as a TurboFan code stub.

src/bootstrapper.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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/code-stubs.h"
@@ skipping 3656 matching lines @@
   Isolate* isolate = global->GetIsolate();
   Factory* factory = isolate->factory();
 
   LookupIterator it1(global, factory->NewStringFromAsciiChecked("Array"),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
   Handle<Object> array_object = Object::GetProperty(&it1).ToHandleChecked();
   LookupIterator it2(array_object,
                      factory->NewStringFromAsciiChecked("prototype"),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
   Handle<Object> array_prototype = Object::GetProperty(&it2).ToHandleChecked();
+
   LookupIterator it3(array_prototype,
                      factory->NewStringFromAsciiChecked("forEach"),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
   Handle<Object> for_each_function =
       Object::GetProperty(&it3).ToHandleChecked();
   Handle<JSFunction>::cast(for_each_function)
       ->set_code(isolate->builtins()->builtin(Builtins::kArrayForEach));
   Handle<JSFunction>::cast(for_each_function)
       ->shared()
       ->set_code(isolate->builtins()->builtin(Builtins::kArrayForEach));
@@ skipping 10 matching lines @@
 
   LookupIterator it5(array_prototype,
                      factory->NewStringFromAsciiChecked("some"),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
   Handle<Object> some_function = Object::GetProperty(&it5).ToHandleChecked();
   Handle<JSFunction>::cast(some_function)
       ->set_code(isolate->builtins()->builtin(Builtins::kArraySome));
   Handle<JSFunction>::cast(some_function)
       ->shared()
       ->set_code(isolate->builtins()->builtin(Builtins::kArraySome));
+
+  if (FLAG_csa_builtin_filter) {

[danno, 2017/03/20 08:06:25]

Instead of introducing a new flag, how about you just remove the implication
from --turbo on FLAG_enable_fast_array_builtins, and then use that flag to
check/bail out here if it's not set, and all new "experimental" builtins would
be installed after that check.

[mvstanton, 2017/03/20 16:10:52]

I like the idea, but right now the filter implementation still needs work (for
example the CreateDataProperty call we want to eliminate). Being able to turn it
on and off (and it'll be off by default in this first CL) lets me run the
microbenchmarks at the command prompt and see the difference. I don't want to
permute the environment by turning off our other CSAs...

The flag is temporary and should disappear within a couple weeks...would that be
okay?

+    LookupIterator it6(array_prototype,
+                       factory->NewStringFromAsciiChecked("filter"),
+                       LookupIterator::OWN_SKIP_INTERCEPTOR);
+    Handle<Object> filter_function =
+        Object::GetProperty(&it6).ToHandleChecked();
+    Handle<JSFunction>::cast(filter_function)
+        ->set_code(isolate->builtins()->builtin(Builtins::kArrayFilter));
+    Handle<JSFunction>::cast(filter_function)
+        ->shared()
+        ->set_code(isolate->builtins()->builtin(Builtins::kArrayFilter));
+  }
 }
 
 void Genesis::InitializeGlobal_harmony_sharedarraybuffer() {
   if (!FLAG_harmony_sharedarraybuffer) return;
 
   Handle<JSGlobalObject> global(native_context()->global_object());
   Isolate* isolate = global->GetIsolate();
   Factory* factory = isolate->factory();
 
   Handle<JSFunction> shared_array_buffer_fun =
@@ skipping 1344 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8