Merge V8 5.2.361.47 DO NOT MERGE
https://chromium.googlesource.com/v8/v8/+/5.2.361.47
FPIIM-449
Change-Id: Ibec421b85a9b88cb3a432ada642e469fe7e78346
(cherry picked from commit bcf72ee8e3b26f1d0726869c7ddb3921c68b09a8)
diff --git a/src/heap/spaces-inl.h b/src/heap/spaces-inl.h
index 135498f..f9e40bb 100644
--- a/src/heap/spaces-inl.h
+++ b/src/heap/spaces-inl.h
@@ -56,8 +56,8 @@
HeapObject* SemiSpaceIterator::Next() {
while (current_ != limit_) {
- if (NewSpacePage::IsAtEnd(current_)) {
- NewSpacePage* page = NewSpacePage::FromLimit(current_);
+ if (Page::IsAlignedToPageSize(current_)) {
+ Page* page = Page::FromAllocationAreaAddress(current_);
page = page->next_page();
DCHECK(!page->is_anchor());
current_ = page->area_start();
@@ -80,9 +80,9 @@
// NewSpacePageIterator
NewSpacePageIterator::NewSpacePageIterator(NewSpace* space)
- : prev_page_(NewSpacePage::FromAddress(space->ToSpaceStart())->prev_page()),
- next_page_(NewSpacePage::FromAddress(space->ToSpaceStart())),
- last_page_(NewSpacePage::FromLimit(space->ToSpaceEnd())) {}
+ : prev_page_(Page::FromAddress(space->ToSpaceStart())->prev_page()),
+ next_page_(Page::FromAddress(space->ToSpaceStart())),
+ last_page_(Page::FromAllocationAreaAddress(space->ToSpaceEnd())) {}
NewSpacePageIterator::NewSpacePageIterator(SemiSpace* space)
: prev_page_(space->anchor()),
@@ -90,17 +90,16 @@
last_page_(prev_page_->prev_page()) {}
NewSpacePageIterator::NewSpacePageIterator(Address start, Address limit)
- : prev_page_(NewSpacePage::FromAddress(start)->prev_page()),
- next_page_(NewSpacePage::FromAddress(start)),
- last_page_(NewSpacePage::FromLimit(limit)) {
+ : prev_page_(Page::FromAddress(start)->prev_page()),
+ next_page_(Page::FromAddress(start)),
+ last_page_(Page::FromAllocationAreaAddress(limit)) {
SemiSpace::AssertValidRange(start, limit);
}
bool NewSpacePageIterator::has_next() { return prev_page_ != last_page_; }
-
-NewSpacePage* NewSpacePageIterator::next() {
+Page* NewSpacePageIterator::next() {
DCHECK(has_next());
prev_page_ = next_page_;
next_page_ = next_page_->next_page();
@@ -251,16 +250,15 @@
return static_cast<AllocationSpace>(Smi::cast(object_)->value());
}
-NewSpacePage* NewSpacePage::Initialize(Heap* heap, MemoryChunk* chunk,
- Executability executable,
- SemiSpace* owner) {
+Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
+ SemiSpace* owner) {
DCHECK_EQ(executable, Executability::NOT_EXECUTABLE);
bool in_to_space = (owner->id() != kFromSpace);
chunk->SetFlag(in_to_space ? MemoryChunk::IN_TO_SPACE
: MemoryChunk::IN_FROM_SPACE);
DCHECK(!chunk->IsFlagSet(in_to_space ? MemoryChunk::IN_FROM_SPACE
: MemoryChunk::IN_TO_SPACE));
- NewSpacePage* page = static_cast<NewSpacePage*>(chunk);
+ Page* page = static_cast<Page*>(chunk);
heap->incremental_marking()->SetNewSpacePageFlags(page);
return page;
}
@@ -268,6 +266,7 @@
// --------------------------------------------------------------------------
// PagedSpace
+template <Page::InitializationMode mode>
Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
PagedSpace* owner) {
Page* page = reinterpret_cast<Page*>(chunk);
@@ -280,11 +279,26 @@
// Make sure that categories are initialized before freeing the area.
page->InitializeFreeListCategories();
- owner->Free(page->area_start(), page->area_size());
+ // In the case we do not free the memory, we effectively account for the whole
+ // page as allocated memory that cannot be used for further allocations.
+ if (mode == kFreeMemory) {
+ owner->Free(page->area_start(), page->area_size());
+ }
return page;
}
+Page* Page::ConvertNewToOld(Page* old_page, PagedSpace* new_owner) {
+ DCHECK(old_page->InNewSpace());
+ old_page->set_owner(new_owner);
+ old_page->SetFlags(0, ~0);
+ new_owner->AccountCommitted(old_page->size());
+ Page* new_page = Page::Initialize<kDoNotFreeMemory>(
+ old_page->heap(), old_page, NOT_EXECUTABLE, new_owner);
+ new_page->InsertAfter(new_owner->anchor()->prev_page());
+ return new_page;
+}
+
void Page::InitializeFreeListCategories() {
for (int i = kFirstCategory; i < kNumberOfCategories; i++) {
categories_[i].Initialize(static_cast<FreeListCategoryType>(i));
@@ -325,14 +339,14 @@
bool PagedSpace::Contains(Address addr) {
Page* p = Page::FromAddress(addr);
- if (!p->is_valid()) return false;
+ if (!Page::IsValid(p)) return false;
return p->owner() == this;
}
bool PagedSpace::Contains(Object* o) {
if (!o->IsHeapObject()) return false;
Page* p = Page::FromAddress(HeapObject::cast(o)->address());
- if (!p->is_valid()) return false;
+ if (!Page::IsValid(p)) return false;
return p->owner() == this;
}
@@ -382,8 +396,10 @@
}
void Page::ClearEvacuationCandidate() {
- DCHECK_NULL(old_to_old_slots_);
- DCHECK_NULL(typed_old_to_old_slots_);
+ if (!IsFlagSet(COMPACTION_WAS_ABORTED)) {
+ DCHECK_NULL(old_to_old_slots_);
+ DCHECK_NULL(typed_old_to_old_slots_);
+ }
ClearFlag(EVACUATION_CANDIDATE);
InitializeFreeListCategories();
}
@@ -436,16 +452,6 @@
return nullptr;
}
-void Page::set_next_page(Page* page) {
- DCHECK(page->owner() == owner());
- set_next_chunk(page);
-}
-
-void Page::set_prev_page(Page* page) {
- DCHECK(page->owner() == owner());
- set_prev_chunk(page);
-}
-
Page* FreeListCategory::page() {
return Page::FromAddress(reinterpret_cast<Address>(this));
}
@@ -668,15 +674,19 @@
return AllocateRaw(size_in_bytes, alignment);
}
-
-LargePage* LargePage::Initialize(Heap* heap, MemoryChunk* chunk) {
+LargePage* LargePage::Initialize(Heap* heap, MemoryChunk* chunk,
+ Executability executable, Space* owner) {
+ if (executable && chunk->size() > LargePage::kMaxCodePageSize) {
+ STATIC_ASSERT(LargePage::kMaxCodePageSize <= TypedSlotSet::kMaxOffset);
+ FATAL("Code page is too large.");
+ }
heap->incremental_marking()->SetOldSpacePageFlags(chunk);
return static_cast<LargePage*>(chunk);
}
intptr_t LargeObjectSpace::Available() {
- return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
+ return ObjectSizeFor(heap()->memory_allocator()->Available());
}