Revert "[heap] Register executable MemoryChunks."

hannespayer · Commit Bot · commit 594a1a0b6e55 · 2018-01-17T20:10:06.000Z
This reverts commit e97daee. Bug: chromium:803046,chromium:774108,v8:6792 Change-Id: I15ee3c109b22fa9fe9658c93bd73cb4454310df5 Reviewed-on: https://chromium-review.googlesource.com/870837 Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Commit-Queue: Hannes Payer <hpayer@chromium.org> Cr-Commit-Position: refs/heads/master@{#50664}
diff --git a/src/heap/heap-inl.h b/src/heap/heap-inl.h
@@ -626,7 +626,6 @@ CodeSpaceMemoryModificationScope::CodeSpaceMemoryModificationScope(Heap* heap)
     LargePage* page = heap_->lo_space()->first_page();
     while (page != nullptr) {
       if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {
-        CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
         page->SetReadAndWritable();
       }
       page = page->next_page();
@@ -641,7 +640,6 @@ CodeSpaceMemoryModificationScope::~CodeSpaceMemoryModificationScope() {
     LargePage* page = heap_->lo_space()->first_page();
     while (page != nullptr) {
       if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {
-        CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
         page->SetReadAndExecutable();
       }
       page = page->next_page();
@@ -658,14 +656,12 @@ CodePageMemoryModificationScope::CodePageMemoryModificationScope(
     DCHECK(chunk_->owner()->identity() == CODE_SPACE ||
            (chunk_->owner()->identity() == LO_SPACE &&
             chunk_->IsFlagSet(MemoryChunk::IS_EXECUTABLE)));
-    CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));
     chunk_->SetReadAndWritable();
   }
 }
 
 CodePageMemoryModificationScope::~CodePageMemoryModificationScope() {
   if (scope_active_) {
-    CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));
     chunk_->SetReadAndExecutable();
   }
 }
diff --git a/src/heap/spaces.cc b/src/heap/spaces.cc
@@ -826,13 +826,8 @@ MemoryChunk* MemoryAllocator::AllocateChunk(size_t reserve_area_size,
                          owner);
   }
 
-  MemoryChunk* chunk =
-      MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,
-                              executable, owner, &reservation);
-
-  if (executable) RegisterExecutableMemoryChunk(chunk);
-
-  return chunk;
+  return MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,
+                                 executable, owner, &reservation);
 }
 
 void Page::ResetAllocatedBytes() { allocated_bytes_ = area_size(); }
@@ -975,8 +970,6 @@ void MemoryAllocator::PreFreeMemory(MemoryChunk* chunk) {
   }
 
   chunk->SetFlag(MemoryChunk::PRE_FREED);
-
-  if (chunk->executable()) UnregisterExecutableMemoryChunk(chunk);
 }
 
 
@@ -1729,15 +1722,13 @@ void PagedSpace::ReleasePage(Page* page) {
 void PagedSpace::SetReadAndExecutable() {
   DCHECK(identity() == CODE_SPACE);
   for (Page* page : *this) {
-    CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
     page->SetReadAndExecutable();
   }
 }
 
 void PagedSpace::SetReadAndWritable() {
   DCHECK(identity() == CODE_SPACE);
   for (Page* page : *this) {
-    CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
     page->SetReadAndWritable();
   }
 }
diff --git a/src/heap/spaces.h b/src/heap/spaces.h
@@ -1359,12 +1359,6 @@ class V8_EXPORT_PRIVATE MemoryAllocator {
   // and false otherwise.
   bool CommitBlock(Address start, size_t size, Executability executable);
 
-  // Checks if an allocated MemoryChunk was intended to be used for executable
-  // memory.
-  bool IsMemoryChunkExecutable(MemoryChunk* chunk) {
-    return executable_memory_.find(chunk) != executable_memory_.end();
-  }
-
   // Uncommit a contiguous block of memory [start..(start+size)[.
   // start is not nullptr, the size is greater than zero, and the
   // block is contained in the initial chunk.  Returns true if it succeeded
@@ -1415,17 +1409,6 @@ class V8_EXPORT_PRIVATE MemoryAllocator {
     } while ((high > ptr) && !highest_ever_allocated_.TrySetValue(ptr, high));
   }
 
-  void RegisterExecutableMemoryChunk(MemoryChunk* chunk) {
-    DCHECK(chunk->IsFlagSet(MemoryChunk::IS_EXECUTABLE));
-    DCHECK_EQ(executable_memory_.find(chunk), executable_memory_.end());
-    executable_memory_.insert(chunk);
-  }
-
-  void UnregisterExecutableMemoryChunk(MemoryChunk* chunk) {
-    DCHECK_NE(executable_memory_.find(chunk), executable_memory_.end());
-    executable_memory_.erase(chunk);
-  }
-
   Isolate* isolate_;
   CodeRange* code_range_;
 
@@ -1448,9 +1431,6 @@ class V8_EXPORT_PRIVATE MemoryAllocator {
   VirtualMemory last_chunk_;
   Unmapper unmapper_;
 
-  // Data structure to remember allocated executable memory chunks.
-  std::unordered_set<MemoryChunk*> executable_memory_;
-
   friend class heap::TestCodeRangeScope;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MemoryAllocator);

Original file line number	Diff line number	Diff line change
`@@ -626,7 +626,6 @@ CodeSpaceMemoryModificationScope::CodeSpaceMemoryModificationScope(Heap* heap)`
`626`	`626`	`LargePage* page = heap_->lo_space()->first_page();`
`627`	`627`	`while (page != nullptr) {`
`628`	`628`	`if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {`
`629`		`- CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`630`	`629`	`page->SetReadAndWritable();`
`631`	`630`	`}`
`632`	`631`	`page = page->next_page();`
`@@ -641,7 +640,6 @@ CodeSpaceMemoryModificationScope::~CodeSpaceMemoryModificationScope() {`
`641`	`640`	`LargePage* page = heap_->lo_space()->first_page();`
`642`	`641`	`while (page != nullptr) {`
`643`	`642`	`if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {`
`644`		`- CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`645`	`643`	`page->SetReadAndExecutable();`
`646`	`644`	`}`
`647`	`645`	`page = page->next_page();`
`@@ -658,14 +656,12 @@ CodePageMemoryModificationScope::CodePageMemoryModificationScope(`
`658`	`656`	`DCHECK(chunk_->owner()->identity() == CODE_SPACE \|\|`
`659`	`657`	`(chunk_->owner()->identity() == LO_SPACE &&`
`660`	`658`	`chunk_->IsFlagSet(MemoryChunk::IS_EXECUTABLE)));`
`661`		`- CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));`
`662`	`659`	`chunk_->SetReadAndWritable();`
`663`	`660`	`}`
`664`	`661`	`}`
`665`	`662`
`666`	`663`	`CodePageMemoryModificationScope::~CodePageMemoryModificationScope() {`
`667`	`664`	`if (scope_active_) {`
`668`		`- CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));`
`669`	`665`	`chunk_->SetReadAndExecutable();`
`670`	`666`	`}`
`671`	`667`	`}`
Original file line number	Diff line number	Diff line change
`@@ -826,13 +826,8 @@ MemoryChunk* MemoryAllocator::AllocateChunk(size_t reserve_area_size,`
`826`	`826`	`owner);`
`827`	`827`	`}`
`828`	`828`
`829`		`- MemoryChunk* chunk =`
`830`		`- MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,`
`831`		`- executable, owner, &reservation);`
`832`		`-`
`833`		`- if (executable) RegisterExecutableMemoryChunk(chunk);`
`834`		`-`
`835`		`- return chunk;`
	`829`	`+ return MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,`
	`830`	`+ executable, owner, &reservation);`
`836`	`831`	`}`
`837`	`832`
`838`	`833`	`void Page::ResetAllocatedBytes() { allocated_bytes_ = area_size(); }`
`@@ -975,8 +970,6 @@ void MemoryAllocator::PreFreeMemory(MemoryChunk* chunk) {`
`975`	`970`	`}`
`976`	`971`
`977`	`972`	`chunk->SetFlag(MemoryChunk::PRE_FREED);`
`978`		`-`
`979`		`- if (chunk->executable()) UnregisterExecutableMemoryChunk(chunk);`
`980`	`973`	`}`
`981`	`974`
`982`	`975`
`@@ -1729,15 +1722,13 @@ void PagedSpace::ReleasePage(Page* page) {`
`1729`	`1722`	`void PagedSpace::SetReadAndExecutable() {`
`1730`	`1723`	`DCHECK(identity() == CODE_SPACE);`
`1731`	`1724`	`for (Page* page : *this) {`
`1732`		`- CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`1733`	`1725`	`page->SetReadAndExecutable();`
`1734`	`1726`	`}`
`1735`	`1727`	`}`
`1736`	`1728`
`1737`	`1729`	`void PagedSpace::SetReadAndWritable() {`
`1738`	`1730`	`DCHECK(identity() == CODE_SPACE);`
`1739`	`1731`	`for (Page* page : *this) {`
`1740`		`- CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`1741`	`1732`	`page->SetReadAndWritable();`
`1742`	`1733`	`}`
`1743`	`1734`	`}`