Handlify DescriptorArray::Merge().

R=svenpanne@chromium.org

Review URL: https://codereview.chromium.org/169363002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20339 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/objects.cc

@@ -2726,8 +2726,8 @@ Handle<Map> Map::GeneralizeRepresentation(Handle<Map> old_map,
   }
 
   Handle<DescriptorArray> new_descriptors = DescriptorArray::Merge(
-      updated_descriptors, verbatim, valid, descriptors, modify_index,
-      store_mode, old_descriptors);
+      updated, verbatim, valid, descriptors, modify_index,
+      store_mode, old_map);
   ASSERT(store_mode == ALLOW_AS_CONSTANT ||
          new_descriptors->GetDetails(modify_index).type() == FIELD);
 
@@ -7969,97 +7969,89 @@ void DescriptorArray::CopyFrom(int dst_index,
 }
 
 
-Handle<DescriptorArray> DescriptorArray::Merge(Handle<DescriptorArray> desc,
-                                               int verbatim,
-                                               int valid,
-                                               int new_size,
-                                               int modify_index,
-                                               StoreMode store_mode,
-                                               Handle<DescriptorArray> other) {
-  CALL_HEAP_FUNCTION(desc->GetIsolate(),
-                     desc->Merge(verbatim, valid, new_size, modify_index,
-                                 store_mode, *other),
-                     DescriptorArray);
-}
-
-
-// Generalize the |other| descriptor array by merging it into the (at least
-// partly) updated |this| descriptor array.
+// Creates a new descriptor array by merging the descriptor array of |right_map|
+// into the (at least partly) updated descriptor array of |left_map|.
 // The method merges two descriptor array in three parts. Both descriptor arrays
 // are identical up to |verbatim|. They also overlap in keys up to |valid|.
 // Between |verbatim| and |valid|, the resulting descriptor type as well as the
-// representation are generalized from both |this| and |other|. Beyond |valid|,
-// the descriptors are copied verbatim from |other| up to |new_size|.
-// In case of incompatible types, the type and representation of |other| is
+// representation are generalized from both |left_map| and |right_map|. Beyond
+// |valid|, the descriptors are copied verbatim from |right_map| up to
+// |new_size|.
+// In case of incompatible types, the type and representation of |right_map| is
 // used.
-MaybeObject* DescriptorArray::Merge(int verbatim,
+Handle<DescriptorArray> DescriptorArray::Merge(Handle<Map> left_map,
+                                               int verbatim,
                                                int valid,
                                                int new_size,
                                                int modify_index,
                                                StoreMode store_mode,
-                                    DescriptorArray* other) {
+                                               Handle<Map> right_map) {
   ASSERT(verbatim <= valid);
   ASSERT(valid <= new_size);
 
-  DescriptorArray* result;
   // Allocate a new descriptor array large enough to hold the required
   // descriptors, with minimally the exact same size as this descriptor array.
-  MaybeObject* maybe_descriptors = DescriptorArray::Allocate(
-      GetIsolate(), new_size,
-      Max(new_size, other->number_of_descriptors()) - new_size);
-  if (!maybe_descriptors->To(&result)) return maybe_descriptors;
-  ASSERT(result->length() > length() ||
+  Factory* factory = left_map->GetIsolate()->factory();
+  Handle<DescriptorArray> left(left_map->instance_descriptors());
+  Handle<DescriptorArray> right(right_map->instance_descriptors());
+  Handle<DescriptorArray> result = factory->NewDescriptorArray(
+      new_size, Max(new_size, right->number_of_descriptors()) - new_size);
+  ASSERT(result->length() > left->length() ||
          result->NumberOfSlackDescriptors() > 0 ||
-         result->number_of_descriptors() == other->number_of_descriptors());
+         result->number_of_descriptors() == right->number_of_descriptors());
   ASSERT(result->number_of_descriptors() == new_size);
 
-  DescriptorArray::WhitenessWitness witness(result);
-
   int descriptor;
 
   // 0 -> |verbatim|
   int current_offset = 0;
   for (descriptor = 0; descriptor < verbatim; descriptor++) {
-    if (GetDetails(descriptor).type() == FIELD) current_offset++;
-    result->CopyFrom(descriptor, other, descriptor, witness);
+    if (left->GetDetails(descriptor).type() == FIELD) current_offset++;
+    Descriptor d(right->GetKey(descriptor),
+                 right->GetValue(descriptor),
+                 right->GetDetails(descriptor));
+    result->Set(descriptor, &d);
   }
 
   // |verbatim| -> |valid|
   for (; descriptor < valid; descriptor++) {
-    Name* key = GetKey(descriptor);
-    PropertyDetails details = GetDetails(descriptor);
-    PropertyDetails other_details = other->GetDetails(descriptor);
-
-    if (details.type() == FIELD || other_details.type() == FIELD ||
+    PropertyDetails left_details = left->GetDetails(descriptor);
+    PropertyDetails right_details = right->GetDetails(descriptor);
+    if (left_details.type() == FIELD || right_details.type() == FIELD ||
         (store_mode == FORCE_FIELD && descriptor == modify_index) ||
-        (details.type() == CONSTANT &&
-         other_details.type() == CONSTANT &&
-         GetValue(descriptor) != other->GetValue(descriptor))) {
-      Representation representation =
-          details.representation().generalize(other_details.representation());
-      FieldDescriptor d(key,
+        (left_details.type() == CONSTANT &&
+         right_details.type() == CONSTANT &&
+         left->GetValue(descriptor) != right->GetValue(descriptor))) {
+      Representation representation = left_details.representation().generalize(
+          right_details.representation());
+      FieldDescriptor d(left->GetKey(descriptor),
                         current_offset++,
-                        other_details.attributes(),
+                        right_details.attributes(),
                         representation);
-      result->Set(descriptor, &d, witness);
+      result->Set(descriptor, &d);
     } else {
-      result->CopyFrom(descriptor, other, descriptor, witness);
+      Descriptor d(right->GetKey(descriptor),
+                   right->GetValue(descriptor),
+                   right_details);
+      result->Set(descriptor, &d);
     }
   }
 
   // |valid| -> |new_size|
   for (; descriptor < new_size; descriptor++) {
-    PropertyDetails details = other->GetDetails(descriptor);
-    if (details.type() == FIELD ||
+    PropertyDetails right_details = right->GetDetails(descriptor);
+    if (right_details.type() == FIELD ||
         (store_mode == FORCE_FIELD && descriptor == modify_index)) {
-      Name* key = other->GetKey(descriptor);
-      FieldDescriptor d(key,
+      FieldDescriptor d(right->GetKey(descriptor),
                         current_offset++,
-                        details.attributes(),
-                        details.representation());
-      result->Set(descriptor, &d, witness);
+                        right_details.attributes(),
+                        right_details.representation());
+      result->Set(descriptor, &d);
     } else {
-      result->CopyFrom(descriptor, other, descriptor, witness);
+      Descriptor d(right->GetKey(descriptor),
+                   right->GetValue(descriptor),
+                   right_details);
+      result->Set(descriptor, &d);
     }
   }
 

src/objects.h

@@ -3439,19 +3439,14 @@ class DescriptorArray: public FixedArray {
                 DescriptorArray* src,
                 int src_index,
                 const WhitenessWitness&);
-  static Handle<DescriptorArray> Merge(Handle<DescriptorArray> desc,
+  static Handle<DescriptorArray> Merge(Handle<Map> left_map,
                                        int verbatim,
                                        int valid,
                                        int new_size,
                                        int modify_index,
                                        StoreMode store_mode,
-                                       Handle<DescriptorArray> other);
-  MUST_USE_RESULT MaybeObject* Merge(int verbatim,
-                                     int valid,
-                                     int new_size,
-                                     int modify_index,
-                                     StoreMode store_mode,
-                                     DescriptorArray* other);
+                                       Handle<Map> right_map)
+      V8_WARN_UNUSED_RESULT;
 
   bool IsMoreGeneralThan(int verbatim,
                          int valid,