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

src/hydrogen-instructions.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/hydrogen-instructions.h"
 
 #include "src/base/bits.h"
 #include "src/double.h"
 #include "src/elements.h"
 #include "src/factory.h"
@@ skipping 1287 matching lines @@
 }
 
 
 std::ostream& HTypeofIsAndBranch::PrintDataTo(
     std::ostream& os) const {  // NOLINT
   os << NameOf(value()) << " == " << type_literal()->ToCString().get();
   return HControlInstruction::PrintDataTo(os);
 }
 
 
-static String* TypeOfString(HConstant* constant, Isolate* isolate) {
+namespace {
+
+String* TypeOfString(HConstant* constant, Isolate* isolate) {
   Heap* heap = isolate->heap();
   if (constant->HasNumberValue()) return heap->number_string();
   if (constant->IsUndetectable()) return heap->undefined_string();
   if (constant->HasStringValue()) return heap->string_string();
   switch (constant->GetInstanceType()) {
     case ODDBALL_TYPE: {
       Unique<Object> unique = constant->GetUnique();
       if (unique.IsKnownGlobal(heap->true_value()) ||
           unique.IsKnownGlobal(heap->false_value())) {
         return heap->boolean_string();
@@ skipping 10 matching lines @@
       Unique<Map> map = constant->ObjectMap();
 #define SIMD128_TYPE(TYPE, Type, type, lane_count, lane_type) \
   if (map.IsKnownGlobal(heap->type##_map())) {                \
     return heap->type##_string();                             \
   }
       SIMD128_TYPES(SIMD128_TYPE)
 #undef SIMD128_TYPE
       UNREACHABLE();
       return nullptr;
     }
-    case JS_FUNCTION_TYPE:
-    case JS_FUNCTION_PROXY_TYPE:
-      return heap->function_string();
     default:
+      if (constant->IsCallable()) return heap->function_string();
       return heap->object_string();
   }
 }
 
+}  // namespace
+
 
 bool HTypeofIsAndBranch::KnownSuccessorBlock(HBasicBlock** block) {
   if (FLAG_fold_constants && value()->IsConstant()) {
     HConstant* constant = HConstant::cast(value());
     String* type_string = TypeOfString(constant, isolate());
     bool same_type = type_literal_.IsKnownGlobal(type_string);
     *block = same_type ? FirstSuccessor() : SecondSuccessor();
     return true;
   } else if (value()->representation().IsSpecialization()) {
     bool number_type =
@@ skipping 1353 matching lines @@
   DCHECK_EQ(kHoleNaN, special);
   std::memcpy(&double_value_, &kHoleNanInt64, sizeof(double_value_));
   Initialize(Representation::Double());
 }
 
 
 HConstant::HConstant(Handle<Object> object, Representation r)
     : HTemplateInstruction<0>(HType::FromValue(object)),
       object_(Unique<Object>::CreateUninitialized(object)),
       object_map_(Handle<Map>::null()),
-      bit_field_(HasStableMapValueField::encode(false) |
-                 HasSmiValueField::encode(false) |
-                 HasInt32ValueField::encode(false) |
-                 HasDoubleValueField::encode(false) |
-                 HasExternalReferenceValueField::encode(false) |
-                 IsNotInNewSpaceField::encode(true) |
-                 BooleanValueField::encode(object->BooleanValue()) |
-                 IsUndetectableField::encode(false) |
-                 InstanceTypeField::encode(kUnknownInstanceType)) {
+      bit_field_(
+          HasStableMapValueField::encode(false) |
+          HasSmiValueField::encode(false) | HasInt32ValueField::encode(false) |
+          HasDoubleValueField::encode(false) |
+          HasExternalReferenceValueField::encode(false) |
+          IsNotInNewSpaceField::encode(true) |
+          BooleanValueField::encode(object->BooleanValue()) |
+          IsUndetectableField::encode(false) | IsCallableField::encode(false) |
+          InstanceTypeField::encode(kUnknownInstanceType)) {
   if (object->IsHeapObject()) {
     Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
     Isolate* isolate = heap_object->GetIsolate();
     Handle<Map> map(heap_object->map(), isolate);
     bit_field_ = IsNotInNewSpaceField::update(
         bit_field_, !isolate->heap()->InNewSpace(*object));
     bit_field_ = InstanceTypeField::update(bit_field_, map->instance_type());
     bit_field_ =
         IsUndetectableField::update(bit_field_, map->is_undetectable());
+    bit_field_ = IsCallableField::update(bit_field_, map->is_callable());

[Yang, 2015/08/27 08:39:18]

Do we already use this field?

[Benedikt Meurer, 2015/08/27 08:39:54]

Yep in TypeOfString in the .cc file.

     if (map->is_stable()) object_map_ = Unique<Map>::CreateImmovable(map);
     bit_field_ = HasStableMapValueField::update(
         bit_field_,
         HasMapValue() && Handle<Map>::cast(heap_object)->is_stable());
   }
   if (object->IsNumber()) {
     double n = object->Number();
     bool has_int32_value = IsInteger32(n);
     bit_field_ = HasInt32ValueField::update(bit_field_, has_int32_value);
     int32_value_ = DoubleToInt32(n);
@@ skipping 1972 matching lines @@
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 }  // namespace internal
 }  // namespace v8