From 13918334f8df21b5735e9e172b089590f20311d4 Mon Sep 17 00:00:00 2001 From: "ishell@chromium.org" Date: Wed, 4 Jun 2014 15:21:35 +0000 Subject: [PATCH] Revert "Folding of bounded dynamic size allocations with const size allocations." This reverts r21675. TBR=mvstanton@chromium.org Review URL: https://codereview.chromium.org/311173002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@21679 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/hydrogen-instructions.cc | 142 ++++++++++++++++++------------------------- src/hydrogen-instructions.h | 6 +- 2 files changed, 61 insertions(+), 87 deletions(-) diff --git a/src/hydrogen-instructions.cc b/src/hydrogen-instructions.cc index 1a376b1..44a6dde 100644 --- a/src/hydrogen-instructions.cc +++ b/src/hydrogen-instructions.cc @@ -3757,34 +3757,33 @@ bool HAllocate::HandleSideEffectDominator(GVNFlag side_effect, } HAllocate* dominator_allocate = HAllocate::cast(dominator); + HValue* dominator_size = dominator_allocate->size(); + HValue* current_size = size(); - dominator_allocate = GetFoldableDominator(dominator_allocate); - if (dominator_allocate == NULL) { - return false; - } - - if (!has_size_upper_bound() || !dominator_allocate->has_size_upper_bound()) { + // TODO(hpayer): Add support for non-constant allocation in dominator. + if (!dominator_size->IsInteger32Constant()) { if (FLAG_trace_allocation_folding) { PrintF("#%d (%s) cannot fold into #%d (%s), " - "can't estimate total allocation size\n", + "dynamic allocation size in dominator\n", id(), Mnemonic(), dominator->id(), dominator->Mnemonic()); } return false; } - HValue* dominator_size = dominator_allocate->size(); - // TODO(ishell): support folding of dynamic size allocation with - // double aligned allocation. - if (!dominator_size->IsInteger32Constant() && MustAllocateDoubleAligned()) { + dominator_allocate = GetFoldableDominator(dominator_allocate); + if (dominator_allocate == NULL) { + return false; + } + + if (!has_size_upper_bound()) { if (FLAG_trace_allocation_folding) { - PrintF("#%d (%s) cannot fold into #%d (%s), dynamic size " - "in dominator and double aligned requirement\n", + PrintF("#%d (%s) cannot fold into #%d (%s), " + "can't estimate total allocation size\n", id(), Mnemonic(), dominator->id(), dominator->Mnemonic()); } return false; } - HValue* current_size = size(); if (!current_size->IsInteger32Constant()) { // If it's not constant then it is a size_in_bytes calculation graph // like this: (const_header_size + const_element_size * size). @@ -3809,82 +3808,61 @@ bool HAllocate::HandleSideEffectDominator(GVNFlag side_effect, (IsOldPointerSpaceAllocation() && dominator_allocate->IsOldPointerSpaceAllocation())); - // First update the size and size upper bound of the dominator allocate - // instruction. - int32_t dominator_size_upper_bound_value = - dominator_allocate->size_upper_bound()->GetInteger32Constant(); + // First update the size of the dominator allocate instruction. + dominator_size = dominator_allocate->size(); + int32_t original_object_size = + HConstant::cast(dominator_size)->GetInteger32Constant(); + int32_t dominator_size_constant = original_object_size; if (MustAllocateDoubleAligned()) { - if ((dominator_size_upper_bound_value & kDoubleAlignmentMask) != 0) { - dominator_size_upper_bound_value += kDoubleSize / 2; + if ((dominator_size_constant & kDoubleAlignmentMask) != 0) { + dominator_size_constant += kDoubleSize / 2; } } - int32_t new_dominator_size_upper_bound_value = - dominator_size_upper_bound_value + - size_upper_bound()->GetInteger32Constant(); + int32_t current_size_max_value = size_upper_bound()->GetInteger32Constant(); + int32_t new_dominator_size = dominator_size_constant + current_size_max_value; // Since we clear the first word after folded memory, we cannot use the // whole Page::kMaxRegularHeapObjectSize memory. - if (new_dominator_size_upper_bound_value > - Page::kMaxRegularHeapObjectSize - kPointerSize) { + if (new_dominator_size > Page::kMaxRegularHeapObjectSize - kPointerSize) { if (FLAG_trace_allocation_folding) { PrintF("#%d (%s) cannot fold into #%d (%s) due to size: %d\n", id(), Mnemonic(), dominator_allocate->id(), - dominator_allocate->Mnemonic(), new_dominator_size_upper_bound_value); + dominator_allocate->Mnemonic(), new_dominator_size); } return false; } - HValue* aligned_dominator_size; - if (dominator_size->IsInteger32Constant()) { - aligned_dominator_size = + HInstruction* new_dominator_size_value; + + if (current_size->IsInteger32Constant()) { + new_dominator_size_value = HConstant::CreateAndInsertBefore(zone, context(), - dominator_size_upper_bound_value, - Representation::Integer32(), + new_dominator_size, + Representation::None(), dominator_allocate); - } else { - aligned_dominator_size = dominator_size; - } - - HConstant* new_dominator_size_upper_bound = - HConstant::CreateAndInsertBefore(zone, - context(), - new_dominator_size_upper_bound_value, - Representation::None(), - dominator_allocate); - - HInstruction* new_dominator_size; - if (current_size->IsInteger32Constant() && - dominator_size->IsInteger32Constant()) { - new_dominator_size = new_dominator_size_upper_bound; + HValue* new_dominator_size_constant = + HConstant::CreateAndInsertBefore(zone, + context(), + dominator_size_constant, + Representation::Integer32(), + dominator_allocate); - } else { // Add old and new size together and insert. - if (current_size->IsInteger32Constant()) { - // Create a copy of constant and put it into the right place - current_size = - HConstant::CreateAndInsertBefore(zone, - context(), - current_size->GetInteger32Constant(), - Representation::Integer32(), - dominator_allocate); - } else { - current_size->ChangeRepresentation(Representation::Integer32()); - } + current_size->ChangeRepresentation(Representation::Integer32()); - new_dominator_size = HAdd::New(zone, context(), - aligned_dominator_size, current_size); - new_dominator_size->ClearFlag(HValue::kCanOverflow); - new_dominator_size->ChangeRepresentation(Representation::Integer32()); + new_dominator_size_value = HAdd::New(zone, context(), + new_dominator_size_constant, current_size); + new_dominator_size_value->ClearFlag(HValue::kCanOverflow); + new_dominator_size_value->ChangeRepresentation(Representation::Integer32()); - new_dominator_size->InsertBefore(dominator_allocate); + new_dominator_size_value->InsertBefore(dominator_allocate); } - dominator_allocate->UpdateSize(new_dominator_size, - new_dominator_size_upper_bound); + dominator_allocate->UpdateSize(new_dominator_size_value); if (MustAllocateDoubleAligned()) { if (!dominator_allocate->MustAllocateDoubleAligned()) { @@ -3902,17 +3880,24 @@ bool HAllocate::HandleSideEffectDominator(GVNFlag side_effect, } else { // TODO(hpayer): This is a short-term hack to make allocation mementos // work again in new space. - dominator_allocate->ClearNextMapWord(dominator_size); + dominator_allocate->ClearNextMapWord(original_object_size); } dominator_allocate->UpdateClearNextMapWord(MustClearNextMapWord()); // After that replace the dominated allocate instruction. + HInstruction* inner_offset = HConstant::CreateAndInsertBefore( + zone, + context(), + dominator_size_constant, + Representation::None(), + this); + HInstruction* dominated_allocate_instr = HInnerAllocatedObject::New(zone, context(), dominator_allocate, - aligned_dominator_size, + inner_offset, type()); dominated_allocate_instr->InsertBefore(this); DeleteAndReplaceWith(dominated_allocate_instr); @@ -4039,25 +4024,14 @@ void HAllocate::CreateFreeSpaceFiller(int32_t free_space_size) { } -void HAllocate::ClearNextMapWord(HValue* offset) { +void HAllocate::ClearNextMapWord(int offset) { if (MustClearNextMapWord()) { Zone* zone = block()->zone(); - - HInstruction* clear_next_map; - if (offset->IsInteger32Constant()) { - int offset_value = HConstant::cast(offset)->GetInteger32Constant(); - HObjectAccess access = - HObjectAccess::ForObservableJSObjectOffset(offset_value); - clear_next_map = - HStoreNamedField::New(zone, context(), this, access, - block()->graph()->GetConstant0()); - } else { - clear_next_map = - HStoreKeyed::New(zone, context(), - this, offset, - block()->graph()->GetConstant0(), - FAST_HOLEY_SMI_ELEMENTS); - } + HObjectAccess access = + HObjectAccess::ForObservableJSObjectOffset(offset); + HStoreNamedField* clear_next_map = + HStoreNamedField::New(zone, context(), this, access, + block()->graph()->GetConstant0()); clear_next_map->ClearAllSideEffects(); clear_next_map->InsertAfter(this); } diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h index 982065c..9e6f0f0 100644 --- a/src/hydrogen-instructions.h +++ b/src/hydrogen-instructions.h @@ -5589,12 +5589,12 @@ class HAllocate V8_FINAL : public HTemplateInstruction<2> { : flags_ & ~CLEAR_NEXT_MAP_WORD); } - void UpdateSize(HValue* size, HConstant* size_upper_bound = NULL) { + void UpdateSize(HValue* size) { SetOperandAt(1, size); if (size->IsInteger32Constant()) { size_upper_bound_ = HConstant::cast(size); } else { - size_upper_bound_ = size_upper_bound; + size_upper_bound_ = NULL; } } @@ -5611,7 +5611,7 @@ class HAllocate V8_FINAL : public HTemplateInstruction<2> { allocate->IsOldPointerSpaceAllocation()); } - void ClearNextMapWord(HValue* offset); + void ClearNextMapWord(int offset); Flags flags_; Handle known_initial_map_; -- 2.7.4