[stubs] Port ToName stub to 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"
@@ skipping 4645 matching lines @@
     }
 
     assembler->Bind(&return_arg);
     assembler->Return(var_arg.value());
 
     assembler->Bind(&return_zero);
     assembler->Return(assembler->SmiConstant(Smi::FromInt(0)));
   }
 }
 
+compiler::Node* ToNameStub::Generate(CodeStubAssembler* assembler,
+                                     compiler::Node* value,
+                                     compiler::Node* context) {
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Variable Variable;
+
+  Label end(assembler);
+  Variable var_result(assembler, MachineRepresentation::kTagged);
+
+  Label is_number(assembler, Label::kDeferred);
+  assembler->GotoIf(assembler->WordIsSmi(value), &is_number);
+
+  Label not_name(assembler, Label::kDeferred);
+  Node* value_instance_type = assembler->LoadInstanceType(value);
+  assembler->GotoIf(
+      assembler->Int32GreaterThan(value_instance_type,
+                                  assembler->Int32Constant(LAST_NAME_TYPE)),
+      &not_name);
+
+  var_result.Bind(value);
+  assembler->Goto(&end);
+
+  assembler->Bind(&is_number);
+  {
+    Callable callable = CodeFactory::NumberToString(assembler->isolate());
+    var_result.Bind(assembler->CallStub(callable, context, value));

[Benedikt Meurer, 2016/09/02 04:36:25]

You can tail call to the stub here.

+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&not_name);
+  {
+    assembler->GotoIf(
+        assembler->Word32Equal(value_instance_type,
+                               assembler->Int32Constant(HEAP_NUMBER_TYPE)),
+        &is_number);
+
+    Label not_oddball(assembler, Label::kDeferred);
+    assembler->GotoIf(
+        assembler->Word32NotEqual(value_instance_type,
+                                  assembler->Int32Constant(ODDBALL_TYPE)),
+        &not_oddball);
+
+    var_result.Bind(
+        assembler->LoadObjectField(value, Oddball::kToStringOffset));
+    assembler->Goto(&end);
+
+    assembler->Bind(&not_oddball);
+    {
+      var_result.Bind(assembler->CallRuntime(Runtime::kToName, context, value));

[Benedikt Meurer, 2016/09/02 04:36:25]

Likewise you can tail call to the runtime here.

+      assembler->Goto(&end);
+    }
+  }
+
+  assembler->Bind(&end);
+  return var_result.value();
+}
+
 void StoreInterceptorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(Descriptor::kReceiver);
   Node* name = assembler->Parameter(Descriptor::kName);
   Node* value = assembler->Parameter(Descriptor::kValue);
   Node* context = assembler->Parameter(Descriptor::kContext);
   assembler->TailCallRuntime(Runtime::kStorePropertyWithInterceptor, context,
                              receiver, name, value);
@@ skipping 405 matching lines @@
 
   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));
+    var_result.Bind(ToNameStub::Generate(assembler, key, context));
     assembler->Goto(&end);
   }
 
   assembler->Bind(&return_undefined);
   {
     var_result.Bind(assembler->UndefinedConstant());
     assembler->Goto(&end);
   }
 
   assembler->Bind(&end);
@@ skipping 745 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8