[turbofan] Stub for typeof operator.

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 1864 matching lines @@
     Node* fdec_result = assembler->Float64Sub(fdec_value, one);
     result_var.Bind(assembler->ChangeFloat64ToTagged(fdec_result));
     assembler->Goto(&end);
   }
 
   assembler->Bind(&end);
   return result_var.value();
 }
 
 // static
+// ES6 section 12.5.5 typeof operator
+compiler::Node* TypeofStub::Generate(CodeStubAssembler* assembler,
+                                     compiler::Node* value,
+                                     compiler::Node* context) {
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
+  typedef CodeStubAssembler::Variable Variable;
+
+  Variable result_var(assembler, MachineRepresentation::kTagged);
+
+  Label return_undefined(assembler), return_number(assembler, Label::kDeferred),
+      return_string(assembler), return_symbol(assembler, Label::kDeferred),
+      return_function(assembler), if_oddball(assembler), if_object(assembler),
+      end(assembler);

[Benedikt Meurer, 2016/08/01 17:27:42]

Nit: I'd prefer to use return_result instead of end as name, as it does
effectively return whatever is in result variable.

[Franzi, 2016/08/01 19:00:33]

Done.

+
+  assembler->GotoIf(assembler->WordIsSmi(value), &return_number);
+
+  Node* map = assembler->LoadMap(value);
+
+  assembler->GotoIf(
+      assembler->WordEqual(map, assembler->HeapNumberMapConstant()),
+      &return_number);
+
+  Node* instance_type = assembler->LoadInstanceType(value);
+
+  assembler->GotoIf(
+      assembler->Int32LessThan(instance_type,
+                               assembler->Int32Constant(FIRST_NONSTRING_TYPE)),
+      &return_string);
+
+  assembler->GotoIf(assembler->Word32Equal(
+                        instance_type, assembler->Int32Constant(ODDBALL_TYPE)),
+                    &if_oddball);
+
+  assembler->GotoIf(assembler->Word32Equal(
+                        instance_type, assembler->Int32Constant(SYMBOL_TYPE)),
+                    &return_symbol);
+
+  assembler->GotoIf(assembler->Word32NotEqual(

[Benedikt Meurer, 2016/08/01 17:27:42]

Nit: Use GotoUnless with Word32Equal instead.

[Franzi, 2016/08/01 19:00:32]

Done.

+                        assembler->Word32And(assembler->LoadMapBitField(map),
+                                             assembler->Int32Constant(
+                                                 1 << Map::kIsUndetectable)),
+                        assembler->Int32Constant(0)),
+                    &return_undefined);
+
+  assembler->Branch(

[Benedikt Meurer, 2016/08/01 17:27:42]

Nit: Use GotoIf here as well, and continue the flat checking with the SIMD
types.

[Franzi, 2016/08/01 19:00:32]

Done.

+      assembler->Word32Equal(
+          assembler->Word32And(assembler->LoadMapBitField(map),
+                               assembler->Int32Constant(1 << Map::kIsCallable)),
+          assembler->Int32Constant(0)),
+      &if_object, &return_function);

[Benedikt Meurer, 2016/08/01 17:27:42]

I think we could rearrange it a bit, so that we check for is callable here, and
if so return "function", next check for instance_type >= FIRST_JS_RECEIVER_TYPE
and if so return "object", and then do the SIMD types, and as fallback do the
SYMBOL_TYPE (which is the most unlikely case I'd guess). Or in summary, I'd
propose this order:

1. Smi -> "number"
2. HeapNumber -> "number"
3. Oddball -> load typeof
4. let mask = map->bit_field & (1 << kIsCallable | 1 << kIsUndetectable) in
  4a. if mask == 1 << kIsCallable -> "function"
  4b. if mask != 0 -> "undefined"
  4c.if instance_type >= FIRST_JS_RECEIVER_TYPE -> "object"
5. String -> "string"
6...16. Simd128Value types -> type string
17. otherwise (assert Symbol) -> "symbol"

[Franzi, 2016/08/01 19:00:32]

Changed the order. Makes sense to have the unlikely cases towards the end. 

+
+  assembler->Bind(&if_oddball);
+  {
+    Node* type = assembler->LoadObjectField(value, Oddball::kTypeOfOffset);
+    result_var.Bind(type);
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&if_object);
+  {
+#define SIMD128_BRANCH(TYPE, Type, type, lane_count, lane_type)    \
+  Label return_##type(assembler);                                  \
+  Node* type##_map =                                               \
+      assembler->HeapConstant(assembler->factory()->type##_map()); \
+  assembler->GotoIf(assembler->WordEqual(map, type##_map), &return_##type);
+    SIMD128_TYPES(SIMD128_BRANCH)
+#undef SIMD128_BRANCH
+
+    result_var.Bind(assembler->HeapConstant(
+        assembler->isolate()->factory()->object_string()));
+    assembler->Goto(&end);
+
+#define SIMD128_BIND_RETURN(TYPE, Type, type, lane_count, lane_type) \
+  assembler->Bind(&return_##type);                                   \
+  {                                                                  \
+    result_var.Bind(assembler->HeapConstant(                         \
+        assembler->isolate()->factory()->type##_string()));          \
+    assembler->Goto(&end);                                           \
+  }
+    SIMD128_TYPES(SIMD128_BIND_RETURN)
+#undef SIMD128_BIND_RETURN
+  }
+
+  assembler->Bind(&return_number);
+  {
+    result_var.Bind(assembler->HeapConstant(
+        assembler->isolate()->factory()->number_string()));
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&return_string);
+  {
+    result_var.Bind(assembler->HeapConstant(
+        assembler->isolate()->factory()->string_string()));
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&return_symbol);
+  {
+    result_var.Bind(assembler->HeapConstant(
+        assembler->isolate()->factory()->symbol_string()));
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&return_undefined);
+  {
+    result_var.Bind(assembler->HeapConstant(
+        assembler->isolate()->factory()->undefined_string()));
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&return_function);
+  {
+    result_var.Bind(assembler->HeapConstant(
+        assembler->isolate()->factory()->function_string()));
+    assembler->Goto(&end);
+  }
+
+  assembler->Bind(&end);
+  return result_var.value();
+}
+
+// static
 compiler::Node* InstanceOfStub::Generate(CodeStubAssembler* assembler,
                                          compiler::Node* object,
                                          compiler::Node* callable,
                                          compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
   Label return_runtime(assembler, Label::kDeferred), end(assembler);
   Variable result(assembler, MachineRepresentation::kTagged);
 
@@ skipping 2198 matching lines @@
 void ToObjectStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(Runtime::FunctionForId(Runtime::kToObject)->entry);
   descriptor->SetMissHandler(Runtime::kToObject);
 }
 
 void StoreTransitionStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       FUNCTION_ADDR(Runtime_TransitionStoreIC_MissFromStubFailure));
 }
 
-void TypeofStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
-  descriptor->SetMissHandler(Runtime::kTypeof);
-}
-
 void NumberToStringStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kNumberToString)->entry);
   descriptor->SetMissHandler(Runtime::kNumberToString);
 }
 
 
 void FastCloneRegExpStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   FastCloneRegExpDescriptor call_descriptor(isolate());
   descriptor->Initialize(
@@ skipping 66 matching lines @@
 }
 
 
 void GrowArrayElementsStub::InitializeDescriptor(
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kGrowArrayElements)->entry);
 }
 
 
-void TypeofStub::GenerateAheadOfTime(Isolate* isolate) {
-  TypeofStub stub(isolate);
-  stub.GetCode();
-}
-
 namespace {
 
 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),
@@ skipping 724 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8