Support all fast elements kinds in the major array operations.

src/elements.h

 // 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 94 matching lines @@
                                               uint32_t key,
                                               JSReceiver::DeleteMode mode) = 0;
 
   // If kCopyToEnd is specified as the copy_size to CopyElements, it copies all
   // of elements from source after source_start to the destination array.
   static const int kCopyToEnd = -1;
   // If kCopyToEndAndInitializeToHole is specified as the copy_size to
   // CopyElements, it copies all of elements from source after source_start to
   // destination array, padding any remaining uninitialized elements in the
   // destination array with the hole.
   static const int kCopyToEndAndInitializeToHole = -2;

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

You probably should get rid of this contant above, and instead thread through a
boolean value/enum {FILL_TO_END_WITH_HOLE, DONT_FILL_TO_END_WITH_HOLE} that is
passed as an additional parameter to CopyElements. This would allow your call
sites of CopyXXX that have to post-fill to not have to do so.

 
   // Copy elements from one backing store to another. Typically, callers specify
   // the source JSObject or JSArray in source_holder. If the holder's backing
   // store is available, it can be passed in source and source_holder is
   // ignored.
   MUST_USE_RESULT virtual MaybeObject* CopyElements(
       JSObject* source_holder,
       uint32_t source_start,
       FixedArrayBase* destination,
       ElementsKind destination_kind,
@@ skipping 51 matching lines @@
 
 
 void CopyObjectToObjectElements(FixedArray* from_obj,
                                 ElementsKind from_kind,
                                 uint32_t from_start,
                                 FixedArray* to_obj,
                                 ElementsKind to_kind,
                                 uint32_t to_start,
                                 int copy_size);
 
+MaybeObject* CopyDoubleToObjectElements(FixedDoubleArray* from_obj,

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

Do you really need to add these here? Or can you get away with ElementsAccessors
everywhere?

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

Done.

+                                        uint32_t from_start,
+                                        FixedArray* to_obj,
+                                        ElementsKind to_kind,
+                                        uint32_t to_start,
+                                        int copy_size);
+
+void CopySmiToSmiElements(FixedArray* from_obj,
+                          uint32_t from_start,
+                          FixedArray* to_obj,
+                          uint32_t to_start,
+                          int copy_size);
+
+void CopySmiToDoubleElements(FixedArray* from_obj,
+                             uint32_t from_start,
+                             FixedDoubleArray* to_obj,
+                             uint32_t to_start,
+                             int copy_size);
+
+void CopyDoubleToDoubleElements(FixedDoubleArray* from_obj,
+                                uint32_t from_start,
+                                FixedDoubleArray* to_obj,
+                                uint32_t to_start,
+                                int copy_size);
 
 } }  // namespace v8::internal
 
 #endif  // V8_ELEMENTS_H_