Introduce flag --allocation-site-transitioning

src/objects.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 12578 matching lines @@
       return true;
     }
     current = current_site->weak_next();
   }
   return false;
 }
 
 
 void AllocationSite::DigestTransitionFeedback(Handle<AllocationSite> site,
                                               ElementsKind to_kind) {
+  DCHECK(FLAG_allocation_site_transitioning);
   Isolate* isolate = site->GetIsolate();
 
   if (site->SitePointsToLiteral() && site->transition_info()->IsJSArray()) {
     Handle<JSArray> transition_info =
         handle(JSArray::cast(site->transition_info()));
     ElementsKind kind = transition_info->GetElementsKind();
     // if kind is holey ensure that to_kind is as well.
     if (IsHoleyElementsKind(kind)) {
       to_kind = GetHoleyElementsKind(to_kind);
     }
@@ skipping 35 matching lines @@
           isolate, DependentCode::kAllocationSiteTransitionChangedGroup);
     }
   }
 }
 
 
 // static
 void AllocationSite::AddDependentCompilationInfo(Handle<AllocationSite> site,
                                                  Reason reason,
                                                  CompilationInfo* info) {
+  if ((!FLAG_allocation_site_pretenuring && reason == TENURING) ||
+      (!FLAG_allocation_site_transitioning && reason == TRANSITIONS)) {
+    return;
+  }
+
   DependentCode::DependencyGroup group = site->ToDependencyGroup(reason);
   Handle<DependentCode> dep(site->dependent_code());
   Handle<DependentCode> codes =
       DependentCode::Insert(dep, group, info->object_wrapper());
   if (*codes != site->dependent_code()) site->set_dependent_code(*codes);
   info->dependencies(group)->Add(Handle<HeapObject>(*site), info->zone());
 }
 
 
 const char* AllocationSite::PretenureDecisionName(PretenureDecision decision) {
   switch (decision) {
     case kUndecided: return "undecided";
     case kDontTenure: return "don't tenure";
     case kMaybeTenure: return "maybe tenure";
     case kTenure: return "tenure";
     case kZombie: return "zombie";
     default: UNREACHABLE();
   }
   return NULL;
 }
 
 
 void JSObject::UpdateAllocationSite(Handle<JSObject> object,
                                     ElementsKind to_kind) {
+  if (!FLAG_allocation_site_transitioning) return;
   if (!object->IsJSArray()) return;
 
   Heap* heap = object->GetHeap();
   if (!heap->InNewSpace(*object)) return;
 
   Handle<AllocationSite> site;
   {
     DisallowHeapAllocation no_allocation;
 
     AllocationMemento* memento = heap->FindAllocationMemento(*object);
@@ skipping 3683 matching lines @@
   Handle<DependentCode> codes =
       DependentCode::Insert(handle(cell->dependent_code(), info->isolate()),
                             DependentCode::kPropertyCellChangedGroup,
                             info->object_wrapper());
   if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
   info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
       cell, info->zone());
 }
 
 } }  // namespace v8::internal