Handlify DescriptorArray::Merge().

src/objects.cc

 // Copyright 2013 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 7974 matching lines @@
                                DescriptorArray* src,
                                int src_index,
                                const WhitenessWitness& witness) {
   Object* value = src->GetValue(src_index);
   PropertyDetails details = src->GetDetails(src_index);
   Descriptor desc(src->GetKey(src_index), value, details);
   Set(dst_index, &desc, witness);
 }
 
 
+// Generalize the |other| descriptor array by merging it into the (at least
+// partly) updated |desc| descriptor array.
+// 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 |desc| 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
+// used.
 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.
-// 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
-// used.
-MaybeObject* DescriptorArray::Merge(int verbatim,
-                                    int valid,
-                                    int new_size,
-                                    int modify_index,
-                                    StoreMode store_mode,
-                                    DescriptorArray* other) {
   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() ||
+  Isolate* isolate = desc->GetIsolate();
+  Handle<DescriptorArray> result = isolate->factory()->NewDescriptorArray(
+      new_size, Max(new_size, other->number_of_descriptors()) - new_size);
+  ASSERT(result->length() > desc->length() ||
          result->NumberOfSlackDescriptors() > 0 ||
          result->number_of_descriptors() == other->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 (desc->GetDetails(descriptor).type() == FIELD) current_offset++;
+    Descriptor d(other->GetKey(descriptor),
+                 other->GetValue(descriptor),
+                 other->GetDetails(descriptor));
+    result->Set(descriptor, &d);
   }
 
   // |verbatim| -> |valid|
   for (; descriptor < valid; descriptor++) {
-    Name* key = GetKey(descriptor);
-    PropertyDetails details = GetDetails(descriptor);
+    PropertyDetails details = desc->GetDetails(descriptor);
     PropertyDetails other_details = other->GetDetails(descriptor);
 
     if (details.type() == FIELD || other_details.type() == FIELD ||
         (store_mode == FORCE_FIELD && descriptor == modify_index) ||
         (details.type() == CONSTANT &&
          other_details.type() == CONSTANT &&
-         GetValue(descriptor) != other->GetValue(descriptor))) {
+         desc->GetValue(descriptor) != other->GetValue(descriptor))) {
       Representation representation =
           details.representation().generalize(other_details.representation());
-      FieldDescriptor d(key,
+      FieldDescriptor d(desc->GetKey(descriptor),
                         current_offset++,
                         other_details.attributes(),
                         representation);
-      result->Set(descriptor, &d, witness);
+      result->Set(descriptor, &d);
     } else {
-      result->CopyFrom(descriptor, other, descriptor, witness);
+      Descriptor d(other->GetKey(descriptor),
+                   other->GetValue(descriptor),
+                   other->GetDetails(descriptor));
+      result->Set(descriptor, &d);
     }
   }
 
   // |valid| -> |new_size|
   for (; descriptor < new_size; descriptor++) {
     PropertyDetails details = other->GetDetails(descriptor);
+
     if (details.type() == FIELD ||
         (store_mode == FORCE_FIELD && descriptor == modify_index)) {
-      Name* key = other->GetKey(descriptor);
-      FieldDescriptor d(key,
+      FieldDescriptor d(other->GetKey(descriptor),
                         current_offset++,
                         details.attributes(),
                         details.representation());
-      result->Set(descriptor, &d, witness);
+      result->Set(descriptor, &d);
     } else {
-      result->CopyFrom(descriptor, other, descriptor, witness);
+      Descriptor d(other->GetKey(descriptor),
+                   other->GetValue(descriptor),
+                   other->GetDetails(descriptor));
+      result->Set(descriptor, &d);
     }
   }
 
   result->Sort();
   return result;
 }
 
 
 // Checks whether a merge of |other| into |this| would return a copy of |this|.
 bool DescriptorArray::IsMoreGeneralThan(int verbatim,
@@ skipping 8400 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal