Avoid jumping to the runtime for ForInFilter

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"
@@ skipping 4280 matching lines @@
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kGrowArrayElements)->entry);
 }
 
 
 void TypeofStub::GenerateAheadOfTime(Isolate* isolate) {
   TypeofStub stub(isolate);
   stub.GetCode();
 }
 
+namespace {
+
 // static

[Michael Starzinger, 2016/07/19 15:06:01]

nit: The "static" comment no longer applies.

-compiler::Node* HasPropertyStub::Generate(CodeStubAssembler* assembler,
-                                          compiler::Node* key,
-                                          compiler::Node* object,
-                                          compiler::Node* context) {
+compiler::Node* GenerateHasProperty(
+    CodeStubAssembler* assembler, compiler::Node* object, compiler::Node* key,
+    compiler::Node* context, Runtime::FunctionId fallback_runtime_function_id) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
   Label call_runtime(assembler, Label::kDeferred), return_true(assembler),
       return_false(assembler), end(assembler);
 
   CodeStubAssembler::LookupInHolder lookup_property_in_holder =
       [assembler, &return_true](Node* receiver, Node* holder, Node* holder_map,
                                 Node* holder_instance_type, Node* unique_name,
@@ skipping 24 matching lines @@
   }
 
   assembler->Bind(&return_false);
   {
     result.Bind(assembler->BooleanConstant(false));
     assembler->Goto(&end);
   }
 
   assembler->Bind(&call_runtime);
   {
-    result.Bind(
-        assembler->CallRuntime(Runtime::kHasProperty, context, key, object));
+    result.Bind(assembler->CallRuntime(fallback_runtime_function_id, context,
+                                       object, key));
     assembler->Goto(&end);
   }
 
   assembler->Bind(&end);
   return result.value();
 }
 
+}  // namespace
+
+// static
+compiler::Node* HasPropertyStub::Generate(CodeStubAssembler* assembler,
+                                          compiler::Node* key,
+                                          compiler::Node* object,
+                                          compiler::Node* context) {
+  return GenerateHasProperty(assembler, object, key, context,
+                             Runtime::kHasProperty);
+}
+
+// stati c

[Michael Starzinger, 2016/07/19 15:06:02]

nit: s/stati c/static/

+compiler::Node* ForInFilterStub::Generate(CodeStubAssembler* assembler,
+                                          compiler::Node* key,
+                                          compiler::Node* object,
+                                          compiler::Node* context) {
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
+  typedef CodeStubAssembler::Variable Variable;
+
+  Label return_undefined(assembler, Label::kDeferred),
+      return_to_name(assembler), end(assembler);
+
+  Variable var_result(assembler, MachineRepresentation::kTagged);
+
+  Node* has_property = GenerateHasProperty(assembler, object, key, context,
+                                           Runtime::kForInHasProperty);
+
+  assembler->Branch(
+      assembler->WordEqual(has_property, assembler->BooleanConstant(true)),
+      &return_to_name, &return_undefined);
+
+  assembler->Bind(&return_to_name);
+  {
+    // TODO(cbruni): inline ToName here.
+    Callable callable = CodeFactory::ToName(assembler->isolate());
+    var_result.Bind(assembler->CallStub(callable, context, key));
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&return_undefined);
+  {
+    var_result.Bind(assembler->UndefinedConstant());
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&end);
+  return var_result.value();
+}
+
 void GetPropertyStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
   Label call_runtime(assembler, Label::kDeferred), return_undefined(assembler),
       end(assembler);
 
   Node* object = assembler->Parameter(0);
   Node* key = assembler->Parameter(1);
@@ skipping 567 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8