Support all fast elements kinds in the major array operations.

src/elements.cc

 // Copyright 2012 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 128 matching lines @@
 
 
 static Failure* ThrowArrayLengthRangeError(Heap* heap) {
   HandleScope scope(heap->isolate());
   return heap->isolate()->Throw(
       *heap->isolate()->factory()->NewRangeError("invalid_array_length",
           HandleVector<Object>(NULL, 0)));
 }
 
 
+void CopySmiToSmiElements(FixedArray* from,
+                          uint32_t from_start,
+                          FixedArray* to,
+                          uint32_t to_start,
+                          int copy_size) {
+  ASSERT(to->map() != HEAP->fixed_cow_array_map());
+  ASSERT((copy_size + static_cast<int>(to_start)) <= to->length() &&
+         (copy_size + static_cast<int>(from_start)) <= from->length());

[danno, 2012/11/13 22:05:12]

Please handle the hole here and handle the ElementsAccessor::kCopyToEnd and the
ElementsAccessor::kCopyToEndAndInitializeToHole constants properly.

[Toon Verwaest, 2012/11/14 11:53:13]

Removed this function again now that I just use accessors.

On 2012/11/13 22:05:12, danno wrote:

+  if (copy_size == 0) return;
+  Address to_address = to->address() + FixedArray::kHeaderSize;
+  Address from_address = from->address() + FixedArray::kHeaderSize;
+  CopyWords(reinterpret_cast<Object**>(to_address) + to_start,
+            reinterpret_cast<Object**>(from_address) + from_start,
+            copy_size);
+}
+
+
 void CopyObjectToObjectElements(FixedArray* from,
                                 ElementsKind from_kind,
                                 uint32_t from_start,
                                 FixedArray* to,
                                 ElementsKind to_kind,
                                 uint32_t to_start,
                                 int raw_copy_size) {
   ASSERT(to->map() != HEAP->fixed_cow_array_map());
   int copy_size = raw_copy_size;
   if (raw_copy_size < 0) {
     ASSERT(raw_copy_size == ElementsAccessor::kCopyToEnd ||
            raw_copy_size == ElementsAccessor::kCopyToEndAndInitializeToHole);
     copy_size = Min(from->length() - from_start,
                     to->length() - to_start);
 #ifdef DEBUG
     // FAST_*_ELEMENTS arrays cannot be uninitialized. Ensure they are already
     // marked with the hole.
     if (raw_copy_size == ElementsAccessor::kCopyToEndAndInitializeToHole) {

[danno, 2012/11/13 22:05:12]

If you take my suggestion from the header file, this code (and similar like it
later) will be moved out of #ifdef debug and made conditional by the
FILL/DONT_FILL enum passed in. in the DONT_FILL case, the assert can remain.

       for (int i = to_start + copy_size; i < to->length(); ++i) {
         ASSERT(to->get(i)->IsTheHole());
       }
     }
 #endif
   }
   ASSERT((copy_size + static_cast<int>(to_start)) <= to->length() &&
          (copy_size + static_cast<int>(from_start)) <= from->length());
   if (copy_size == 0) return;
   ASSERT(IsFastSmiOrObjectElementsKind(from_kind));
@@ skipping 59 matching lines @@
     if (!heap->InNewSpace(to)) {
       heap->RecordWrites(to->address(),
                          to->OffsetOfElementAt(to_start),
                          copy_size);
     }
     heap->incremental_marking()->RecordWrites(to);
   }
 }
 
 
-MUST_USE_RESULT static MaybeObject* CopyDoubleToObjectElements(
+MUST_USE_RESULT MaybeObject* CopyDoubleToObjectElements(
     FixedDoubleArray* from,
     uint32_t from_start,
     FixedArray* to,
     ElementsKind to_kind,
     uint32_t to_start,
     int raw_copy_size) {
   ASSERT(IsFastSmiOrObjectElementsKind(to_kind));
   int copy_size = raw_copy_size;
   if (raw_copy_size < 0) {
     ASSERT(raw_copy_size == ElementsAccessor::kCopyToEnd ||
@@ skipping 34 matching lines @@
                                      TENURED);
         if (!maybe_value_object->ToObject(&value)) return maybe_value_object;
       }
       to->set(i + to_start, value, UPDATE_WRITE_BARRIER);
     }
   }
   return to;
 }
 
 
-static void CopyDoubleToDoubleElements(FixedDoubleArray* from,
+void CopyDoubleToDoubleElements(FixedDoubleArray* from,
                                        uint32_t from_start,
                                        FixedDoubleArray* to,
                                        uint32_t to_start,
                                        int raw_copy_size) {
   int copy_size = raw_copy_size;
   if (raw_copy_size < 0) {
     ASSERT(raw_copy_size == ElementsAccessor::kCopyToEnd ||
            raw_copy_size == ElementsAccessor::kCopyToEndAndInitializeToHole);
     copy_size = Min(from->length() - from_start,
                     to->length() - to_start);
@@ skipping 10 matching lines @@
   Address from_address = from->address() + FixedDoubleArray::kHeaderSize;
   to_address += kDoubleSize * to_start;
   from_address += kDoubleSize * from_start;
   int words_per_double = (kDoubleSize / kPointerSize);
   CopyWords(reinterpret_cast<Object**>(to_address),
             reinterpret_cast<Object**>(from_address),
             words_per_double * copy_size);
 }
 
 
-static void CopySmiToDoubleElements(FixedArray* from,
-                                    uint32_t from_start,
-                                    FixedDoubleArray* to,
-                                    uint32_t to_start,
-                                    int raw_copy_size) {
+void CopySmiToDoubleElements(FixedArray* from,
+                             uint32_t from_start,
+                             FixedDoubleArray* to,
+                             uint32_t to_start,
+                             int raw_copy_size) {
   int copy_size = raw_copy_size;
   if (raw_copy_size < 0) {
     ASSERT(raw_copy_size == ElementsAccessor::kCopyToEnd ||
            raw_copy_size == ElementsAccessor::kCopyToEndAndInitializeToHole);
     copy_size = from->length() - from_start;
     if (raw_copy_size == ElementsAccessor::kCopyToEndAndInitializeToHole) {
       for (int i = to_start + copy_size; i < to->length(); ++i) {
         to->set_the_hole(i);
       }
     }
@@ skipping 1400 matching lines @@
   if (!maybe_obj->To(&new_backing_store)) return maybe_obj;
   new_backing_store->set(0, length);
   { MaybeObject* result = array->SetContent(new_backing_store);
     if (result->IsFailure()) return result;
   }
   return array;
 }
 
 
 } }  // namespace v8::internal