[turbofan] Stub for typeof operator.

src/code-stubs-hydrogen.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 <memory>
 
 #include "src/bailout-reason.h"
 #include "src/crankshaft/hydrogen.h"
@@ skipping 325 matching lines @@
   HValue* number = GetParameter(Descriptor::kArgument);
   return BuildNumberToString(number, Type::Number());
 }
 
 
 Handle<Code> NumberToStringStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
-// Returns the type string of a value; see ECMA-262, 11.4.3 (p 47).
-template <>
-HValue* CodeStubGraphBuilder<TypeofStub>::BuildCodeStub() {
-  Factory* factory = isolate()->factory();
-  HConstant* number_string = Add<HConstant>(factory->number_string());
-  HValue* object = GetParameter(Descriptor::kObject);
-
-  IfBuilder is_smi(this);
-  HValue* smi_check = is_smi.If<HIsSmiAndBranch>(object);
-  is_smi.Then();
-  { Push(number_string); }
-  is_smi.Else();
-  {
-    IfBuilder is_number(this);
-    is_number.If<HCompareMap>(object, isolate()->factory()->heap_number_map());
-    is_number.Then();
-    { Push(number_string); }
-    is_number.Else();
-    {
-      HValue* map = AddLoadMap(object, smi_check);
-      HValue* instance_type = Add<HLoadNamedField>(
-          map, nullptr, HObjectAccess::ForMapInstanceType());
-      IfBuilder is_string(this);
-      is_string.If<HCompareNumericAndBranch>(
-          instance_type, Add<HConstant>(FIRST_NONSTRING_TYPE), Token::LT);
-      is_string.Then();
-      { Push(Add<HConstant>(factory->string_string())); }
-      is_string.Else();
-      {
-        HConstant* object_string = Add<HConstant>(factory->object_string());
-        IfBuilder is_oddball(this);
-        is_oddball.If<HCompareNumericAndBranch>(
-            instance_type, Add<HConstant>(ODDBALL_TYPE), Token::EQ);
-        is_oddball.Then();
-        {
-          Push(Add<HLoadNamedField>(object, nullptr,
-                                    HObjectAccess::ForOddballTypeOf()));
-        }
-        is_oddball.Else();
-        {
-          IfBuilder is_symbol(this);
-          is_symbol.If<HCompareNumericAndBranch>(
-              instance_type, Add<HConstant>(SYMBOL_TYPE), Token::EQ);
-          is_symbol.Then();
-          { Push(Add<HConstant>(factory->symbol_string())); }
-          is_symbol.Else();
-          {
-            HValue* bit_field = Add<HLoadNamedField>(
-                map, nullptr, HObjectAccess::ForMapBitField());
-            HValue* bit_field_masked = AddUncasted<HBitwise>(
-                Token::BIT_AND, bit_field,
-                Add<HConstant>((1 << Map::kIsCallable) |
-                               (1 << Map::kIsUndetectable)));
-            IfBuilder is_function(this);
-            is_function.If<HCompareNumericAndBranch>(
-                bit_field_masked, Add<HConstant>(1 << Map::kIsCallable),
-                Token::EQ);
-            is_function.Then();
-            { Push(Add<HConstant>(factory->function_string())); }
-            is_function.Else();
-            {
-#define SIMD128_BUILDER_OPEN(TYPE, Type, type, lane_count, lane_type) \
-  IfBuilder is_##type(this);                                          \
-  is_##type.If<HCompareObjectEqAndBranch>(                            \
-      map, Add<HConstant>(factory->type##_map()));                    \
-  is_##type.Then();                                                   \
-  { Push(Add<HConstant>(factory->type##_string())); }                 \
-  is_##type.Else(); {
-              SIMD128_TYPES(SIMD128_BUILDER_OPEN)
-#undef SIMD128_BUILDER_OPEN
-              // Is it an undetectable object?
-              IfBuilder is_undetectable(this);
-              is_undetectable.If<HCompareNumericAndBranch>(
-                  bit_field_masked, graph()->GetConstant0(), Token::NE);
-              is_undetectable.Then();
-              {
-                // typeof an undetectable object is 'undefined'.
-                Push(Add<HConstant>(factory->undefined_string()));
-              }
-              is_undetectable.Else();
-              {
-                // For any kind of object not handled above, the spec rule for
-                // host objects gives that it is okay to return "object".
-                Push(object_string);
-              }
-#define SIMD128_BUILDER_CLOSE(TYPE, Type, type, lane_count, lane_type) }
-              SIMD128_TYPES(SIMD128_BUILDER_CLOSE)
-#undef SIMD128_BUILDER_CLOSE
-            }
-            is_function.End();
-          }
-          is_symbol.End();
-        }
-        is_oddball.End();
-      }
-      is_string.End();
-    }
-    is_number.End();
-  }
-  is_smi.End();
-
-  return environment()->Pop();
-}
-
-
-Handle<Code> TypeofStub::GenerateCode() { return DoGenerateCode(this); }
-
-
 template <>
 HValue* CodeStubGraphBuilder<FastCloneRegExpStub>::BuildCodeStub() {
   HValue* closure = GetParameter(Descriptor::kClosure);
   HValue* literal_index = GetParameter(Descriptor::kLiteralIndex);
 
   // This stub is very performance sensitive, the generated code must be tuned
   // so that it doesn't build and eager frame.
   info()->MarkMustNotHaveEagerFrame();
 
   HValue* literals_array = Add<HLoadNamedField>(
@@ skipping 1683 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8