Refactor the check for generating inline constructors...

src/objects.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4802 matching lines @@
   }
   return instance_size;
 }
 
 
 int SharedFunctionInfo::CalculateInObjectProperties() {
   return (CalculateInstanceSize() - JSObject::kHeaderSize) / kPointerSize;
 }
 
 
+bool SharedFunctionInfo::CanGenerateInlineConstructor(Object* prototype) {
+  // Check the basic conditions for generating inline constructor code.
+  if (!FLAG_inline_new
+      || !has_only_simple_this_property_assignments()
+      || !this_property_assignments_count() > 0) {
+    return false;
+  }
+
+  // If the prototype is null inline constructors cause no problems.
+  if (!prototype->IsJSObject()) {
+    ASSERT(prototype->IsNull());
+    return true;
+  }
+
+  // Traverse the proposed prototype chain looking for setters for properties of
+  // the same names as are set by the inline constructor..

[Mads Ager (chromium), 2010/02/18 09:19:35]

.. -> .

[Søren Thygesen Gjesse, 2010/02/18 09:42:52]

http://codereview.chromium.org/647007

+  for (Object* obj = prototype;
+       obj != Heap::null_value();
+       obj = obj->GetPrototype()) {
+    JSObject* js_object = JSObject::cast(obj);
+    if (!js_object->HasFastProperties()) {
+      // Only allow fast case objects, as the map check in the inline
+      // constructor which check for changes to the prototype chain cannot
+      // handle dictionary case objects.
+      return false;
+    }
+    for (int i = 0; i < this_property_assignments_count(); i++) {
+      LookupResult result;
+      String* name = GetThisPropertyAssignmentName(i);
+      js_object->LocalLookupRealNamedProperty(name, &result);
+      if (result.IsValid() && result.type() == CALLBACKS) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+
 void SharedFunctionInfo::SetThisPropertyAssignmentsInfo(
     bool only_simple_this_property_assignments,
     FixedArray* assignments) {
   set_compiler_hints(BooleanBit::set(compiler_hints(),
                                      kHasOnlySimpleThisPropertyAssignments,
                                      only_simple_this_property_assignments));
   set_this_property_assignments(assignments);
   set_this_property_assignments_count(assignments->length() / 3);
 }
 
@@ skipping 35 matching lines @@
 
 
 Object* SharedFunctionInfo::GetThisPropertyAssignmentConstant(int index) {
   ASSERT(!IsThisPropertyAssignmentArgument(index));
   Object* obj =
       FixedArray::cast(this_property_assignments())->get(index * 3 + 2);
   return obj;
 }
 
 
-
 // Support function for printing the source code to a StringStream
 // without any allocation in the heap.
 void SharedFunctionInfo::SourceCodePrint(StringStream* accumulator,
                                          int max_length) {
   // For some native functions there is no source.
   if (script()->IsUndefined() ||
       Script::cast(script())->source()->IsUndefined()) {
     accumulator->Add("<No Source>");
     return;
   }
@@ skipping 2334 matching lines @@
 
   if (result <= static_cast<uint32_t>(Smi::kMaxValue)) {
     return Smi::FromInt(static_cast<int>(result));
   }
   ASSERT_NE(NULL, result_double);
   result_double->set_value(static_cast<double>(result));
   return result_double;
 }
 
 
-static bool CallbacksObjectHasSetter(Object* callbacks) {
-  if (!callbacks->IsFixedArray()) {
-    ASSERT(callbacks->IsAccessorInfo() || callbacks->IsProxy());
-    return true;
-  } else {
-    Object* setter = (FixedArray::cast(callbacks))->get(kSetterIndex);
-    if (setter->IsJSFunction()) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-
-bool JSObject::HasSetter() {
-  for (Object* obj = this;
-       obj != Heap::null_value();
-       obj = JSObject::cast(obj)->GetPrototype()) {
-    JSObject* js_object = JSObject::cast(obj);
-    if (js_object->HasFastProperties()) {
-      DescriptorArray* descs = js_object->map()->instance_descriptors();
-      for (int i = 0; i < descs->number_of_descriptors(); i++) {
-        PropertyDetails details = descs->GetDetails(i);
-        if (details.type() == CALLBACKS) {
-          Object* callbacks = descs->GetCallbacksObject(i);
-          if (CallbacksObjectHasSetter(callbacks)) {
-            return true;
-          }
-        }
-      }
-    } else {
-      StringDictionary* dict = js_object->property_dictionary();
-      int capacity = dict->Capacity();
-      for (int i = 0; i < capacity; i++) {
-        Object* k = dict->KeyAt(i);
-        if (dict->IsKey(k)) {
-          PropertyType type = dict->DetailsAt(i).type();
-          ASSERT(type != FIELD);
-          if (type == CALLBACKS) {
-            Object* callbacks = dict->ValueAt(i);
-            if (CallbacksObjectHasSetter(callbacks)) {
-              return true;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
-
-
 Object* PixelArray::SetValue(uint32_t index, Object* value) {
   uint8_t clamped_value = 0;
   if (index < static_cast<uint32_t>(length())) {
     if (value->IsSmi()) {
       int int_value = Smi::cast(value)->value();
       if (int_value < 0) {
         clamped_value = 0;
       } else if (int_value > 255) {
         clamped_value = 255;
       } else {
@@ skipping 1099 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal