[es6] Initial steps towards a correct implementation of IsCallable.

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 "src/bailout-reason.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
 #include "src/ic/ic.h"
@@ skipping 349 matching lines @@
         }
         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);
-            HConstant* js_function = Add<HConstant>(JS_FUNCTION_TYPE);
-            HConstant* js_function_proxy =
-                Add<HConstant>(JS_FUNCTION_PROXY_TYPE);
-            is_function.If<HCompareNumericAndBranch>(instance_type, js_function,
-                                                     Token::EQ);
-            is_function.OrIf<HCompareNumericAndBranch>(
-                instance_type, js_function_proxy, Token::EQ);
+            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<HIsUndetectableAndBranch>(object);
+              is_undetectable.If<HCompareNumericAndBranch>(
+                  bit_field_masked, Add<HConstant>(1 << Map::kIsUndetectable),
+                  Token::EQ);
               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);
@@ skipping 1801 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8