Merged: [crankshaft] Disable further folding already folded allocations.

src/crankshaft/hydrogen-instructions.cc

 // Copyright 2012 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 "src/crankshaft/hydrogen-instructions.h"
 
 #include "src/base/bits.h"
 #include "src/base/ieee754.h"
 #include "src/base/safe_math.h"
 #include "src/crankshaft/hydrogen-infer-representation.h"
@@ skipping 3166 matching lines @@
   if (!current_size->IsInteger32Constant() ||
       !dominator_size->IsInteger32Constant()) {
     if (FLAG_trace_allocation_folding) {
       PrintF("#%d (%s) cannot fold into #%d (%s), "
              "dynamic allocation size in dominator\n",
           id(), Mnemonic(), dominator->id(), dominator->Mnemonic());
     }
     return false;
   }
 
+  if (IsAllocationFoldingDominator()) {
+    if (FLAG_trace_allocation_folding) {
+      PrintF("#%d (%s) cannot fold into #%d (%s), already dominator\n", id(),
+             Mnemonic(), dominator->id(), dominator->Mnemonic());
+    }
+    return false;
+  }
 
   if (!IsFoldable(dominator_allocate)) {
     if (FLAG_trace_allocation_folding) {
       PrintF("#%d (%s) cannot fold into #%d (%s), different spaces\n", id(),
              Mnemonic(), dominator->id(), dominator->Mnemonic());
     }
     return false;
   }
 
   DCHECK(
@@ skipping 31 matching lines @@
       dominator_allocate);
 
   dominator_allocate->UpdateSize(new_dominator_size_value);
 
   if (MustAllocateDoubleAligned()) {
     if (!dominator_allocate->MustAllocateDoubleAligned()) {
       dominator_allocate->MakeDoubleAligned();
     }
   }
 
-  if (IsAllocationFoldingDominator()) {
-    DeleteAndReplaceWith(dominator_allocate);
-    if (FLAG_trace_allocation_folding) {
-      PrintF(
-          "#%d (%s) folded dominator into #%d (%s), new dominator size: %d\n",
-          id(), Mnemonic(), dominator_allocate->id(),
-          dominator_allocate->Mnemonic(), new_dominator_size);
-    }
-    return true;
-  }
-
   if (!dominator_allocate->IsAllocationFoldingDominator()) {
     HAllocate* first_alloc =
         HAllocate::New(isolate, zone, dominator_allocate->context(),
                        dominator_size, dominator_allocate->type(),
                        IsNewSpaceAllocation() ? NOT_TENURED : TENURED,
                        JS_OBJECT_TYPE, block()->graph()->GetConstant0());
     first_alloc->InsertAfter(dominator_allocate);
     dominator_allocate->ReplaceAllUsesWith(first_alloc);
     dominator_allocate->MakeAllocationFoldingDominator();
     first_alloc->MakeFoldedAllocation(dominator_allocate);
@@ skipping 14 matching lines @@
   return true;
 }
 
 
 std::ostream& HAllocate::PrintDataTo(std::ostream& os) const {  // NOLINT
   os << NameOf(size()) << " (";
   if (IsNewSpaceAllocation()) os << "N";
   if (IsOldSpaceAllocation()) os << "P";
   if (MustAllocateDoubleAligned()) os << "A";
   if (MustPrefillWithFiller()) os << "F";
+  if (IsAllocationFoldingDominator()) os << "d";
+  if (IsAllocationFolded()) os << "f";
   return os << ")";
 }
 
 
 bool HStoreKeyed::TryIncreaseBaseOffset(uint32_t increase_by_value) {
   // The base offset is usually simply the size of the array header, except
   // with dehoisting adds an addition offset due to a array index key
   // manipulation, in which case it becomes (array header size +
   // constant-offset-from-key * kPointerSize)
   v8::base::internal::CheckedNumeric<uint32_t> addition_result = base_offset_;
@@ skipping 764 matching lines @@
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 }  // namespace internal
 }  // namespace v8