Adapt Danno's Track Allocation Info idea to fast literals. When allocating a literal array,

src/objects.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 10619 matching lines @@
 MaybeObject* JSObject::TransitionElementsKind(ElementsKind to_kind) {
   ASSERT(!map()->is_observed());
   ElementsKind from_kind = map()->elements_kind();
 
   if (IsFastHoleyElementsKind(from_kind)) {
     to_kind = GetHoleyElementsKind(to_kind);
   }
 
   if (from_kind == to_kind) return this;
 
+  // Are we in new space?
+  if (FLAG_use_allocation_site_info && GetHeap()->InNewSpace(this)) {

[danno, 2012/12/26 10:32:01]

The machinery that checks/gets an AllocationSiteInfo for an Object might be
nicely encapsulated as a static method on the AllocationSiteInfo, either
returning a valid AllocationSizeInfo* or NULL/undefined if there is none.

[mvstanton, 2013/01/03 14:40:43]

Done.

+    // Are we below the top of the heap?
+    Address ptr_end = (reinterpret_cast<Address>(this) - 1) + Size();
+    if ((ptr_end + AllocationSiteInfo::kSize) <= GetHeap()->NewSpaceTop()) {
+      // There is room for allocation info. Do we have some?
+      Map** possible_allocation_map = reinterpret_cast<Map**>(ptr_end);
+      if (*possible_allocation_map == GetHeap()->allocation_site_info_map()) {
+        AllocationSiteInfo* info = AllocationSiteInfo::cast(
+            reinterpret_cast<Object*>(ptr_end + 1));
+        JSObject* payload = JSObject::cast(info->payload());
+        if (payload->GetElementsKind() != to_kind) {
+          if (IsMoreGeneralElementsKindTransition(
+                  payload->GetElementsKind(),
+                  to_kind)) {
+            PrintF("Transitioning array to %s\n",
+                   ElementsKindToString(to_kind));
+            MaybeObject* maybe_result =
+                payload->TransitionElementsKind(to_kind);
+            if (maybe_result->IsFailure()) return maybe_result;
+          }
+        }
+      }
+    }
+  }
+
   Isolate* isolate = GetIsolate();
   if (elements() == isolate->heap()->empty_fixed_array() ||
       (IsFastSmiOrObjectElementsKind(from_kind) &&
        IsFastSmiOrObjectElementsKind(to_kind)) ||
       (from_kind == FAST_DOUBLE_ELEMENTS &&
        to_kind == FAST_HOLEY_DOUBLE_ELEMENTS)) {
     ASSERT(from_kind != TERMINAL_FAST_ELEMENTS_KIND);
     // No change is needed to the elements() buffer, the transition
     // only requires a map change.
     MaybeObject* maybe_new_map = GetElementsTransitionMap(isolate, to_kind);
@@ skipping 3377 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal