FreeList::FindNodeFor should not account for node size twice.

src/heap/spaces.cc

 // Copyright 2011 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/heap/spaces.h"
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/heap/slot-set.h"
@@ skipping 2309 matching lines @@
           ->add_available_in_free_list(-(*node_size));
       DCHECK(IsVeryLong() || Available() == SumFreeLists());
       return node;
     }
   }
   return node;
 }
 
 FreeSpace* FreeList::FindNodeFor(int size_in_bytes, int* node_size) {
   FreeSpace* node = nullptr;
-  Page* page = nullptr;
 
   // First try the allocation fast path: try to allocate the minimum element
   // size of a free list category. This operation is constant time.
   FreeListCategoryType type =
       SelectFastAllocationFreeListCategoryType(size_in_bytes);
   for (int i = type; i < kHuge; i++) {
     node = FindNodeIn(static_cast<FreeListCategoryType>(i), node_size);
     if (node != nullptr) return node;
   }
 
   // Next search the huge list for free list nodes. This takes linear time in
   // the number of huge elements.
   node = SearchForNodeInList(kHuge, node_size, size_in_bytes);
   if (node != nullptr) {
     DCHECK(IsVeryLong() || Available() == SumFreeLists());
     return node;
   }
 
   // We need a huge block of memory, but we didn't find anything in the huge
   // list.
   if (type == kHuge) return nullptr;
 
   // Now search the best fitting free list for a node that has at least the
   // requested size.
   type = SelectFreeListCategoryType(size_in_bytes);
   node = TryFindNodeIn(type, node_size, size_in_bytes);
-  if (node != nullptr) {
-    DCHECK(size_in_bytes <= *node_size);
-    page = Page::FromAddress(node->address());
-    page->add_available_in_free_list(-(*node_size));
-  }
 
   DCHECK(IsVeryLong() || Available() == SumFreeLists());
   return node;
 }
 
 // Allocation on the old space free list.  If it succeeds then a new linear
 // allocation space has been set up with the top and limit of the space.  If
 // the allocation fails then NULL is returned, and the caller can perform a GC
 // or allocate a new page before retrying.
 HeapObject* FreeList::Allocate(int size_in_bytes) {
@@ skipping 795 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8