Call HeapObjectHeader::checkHeader solely for its side-effect.

third_party/WebKit/Source/platform/heap/HeapPage.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 73 matching lines @@
 #define ENABLE_ASAN_CONTAINER_ANNOTATIONS 0
 #define ASAN_RETIRE_CONTAINER_ANNOTATION(payload, payloadSize)
 #define ASAN_MARK_LARGE_VECTOR_CONTAINER(arena, largeObject)
 #endif
 
 namespace blink {
 
 #if DCHECK_IS_ON() && CPU(64BIT)
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::zapMagic() {
-  ASSERT(checkHeader());
+  checkHeader();
   m_magic = zappedMagic;
 }
 #endif
 
 void HeapObjectHeader::finalize(Address object, size_t objectSize) {
   HeapAllocHooks::freeHookIfEnabled(object);
   const GCInfo* gcInfo = ThreadHeap::gcInfo(gcInfoIndex());
   if (gcInfo->hasFinalizer())
     gcInfo->m_finalize(object);
 
@@ skipping 594 matching lines @@
         // invariant that memory on the free list is zero filled.
         // The rest of the memory is already on the free list and is
         // therefore already zero filled.
         SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry)
                                                    ? size
                                                    : sizeof(FreeListEntry));
         CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
         headerAddress += size;
         continue;
       }
-      ASSERT(header->checkHeader());
+      header->checkHeader();
       if (startOfGap != headerAddress)
         addToFreeList(startOfGap, headerAddress - startOfGap);
 
       headerAddress += size;
       startOfGap = headerAddress;
     }
 
     if (startOfGap != page->payloadEnd())
       addToFreeList(startOfGap, page->payloadEnd() - startOfGap);
   }
   getThreadState()->decreaseAllocatedObjectSize(freedSize);
   ASSERT(m_promptlyFreedSize == freedSize);
   m_promptlyFreedSize = 0;
   return true;
 }
 
 void NormalPageArena::promptlyFreeObject(HeapObjectHeader* header) {
   ASSERT(!getThreadState()->sweepForbidden());
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   Address address = reinterpret_cast<Address>(header);
   Address payload = header->payload();
   size_t size = header->size();
   size_t payloadSize = header->payloadSize();
   ASSERT(size > 0);
   ASSERT(pageFromObject(address) == findPageFromAddress(address));
 
   {
     ThreadState::SweepForbiddenScope forbiddenScope(getThreadState());
     header->finalize(payload, payloadSize);
     if (address + size == m_currentAllocationPoint) {
       m_currentAllocationPoint = address;
       setRemainingAllocationSize(m_remainingAllocationSize + size);
       SET_MEMORY_INACCESSIBLE(address, size);
       return;
     }
     SET_MEMORY_INACCESSIBLE(payload, payloadSize);
     header->markPromptlyFreed();
   }
 
   m_promptlyFreedSize += size;
 }
 
 bool NormalPageArena::expandObject(HeapObjectHeader* header, size_t newSize) {
   // It's possible that Vector requests a smaller expanded size because
   // Vector::shrinkCapacity can set a capacity smaller than the actual payload
   // size.
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   if (header->payloadSize() >= newSize)
     return true;
   size_t allocationSize = ThreadHeap::allocationSizeFromSize(newSize);
   ASSERT(allocationSize > header->size());
   size_t expandSize = allocationSize - header->size();
   if (isObjectAllocatedAtAllocationPoint(header) &&
       expandSize <= m_remainingAllocationSize) {
     m_currentAllocationPoint += expandSize;
     ASSERT(m_remainingAllocationSize >= expandSize);
     setRemainingAllocationSize(m_remainingAllocationSize - expandSize);
     // Unpoison the memory used for the object (payload).
     SET_MEMORY_ACCESSIBLE(header->payloadEnd(), expandSize);
     header->setSize(allocationSize);
     ASSERT(findPageFromAddress(header->payloadEnd() - 1));
     return true;
   }
   return false;
 }
 
 bool NormalPageArena::shrinkObject(HeapObjectHeader* header, size_t newSize) {
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   ASSERT(header->payloadSize() > newSize);
   size_t allocationSize = ThreadHeap::allocationSizeFromSize(newSize);
   ASSERT(header->size() > allocationSize);
   size_t shrinkSize = header->size() - allocationSize;
   if (isObjectAllocatedAtAllocationPoint(header)) {
     m_currentAllocationPoint -= shrinkSize;
     setRemainingAllocationSize(m_remainingAllocationSize + shrinkSize);
     SET_MEMORY_INACCESSIBLE(m_currentAllocationPoint, shrinkSize);
     header->setSize(allocationSize);
     return true;
@@ skipping 208 matching lines @@
   for (size_t i = 0; i < largeObjectSize; ++i)
     ASSERT(!largeObjectAddress[i]);
 #endif
   ASSERT(gcInfoIndex > 0);
   HeapObjectHeader* header = new (NotNull, headerAddress)
       HeapObjectHeader(largeObjectSizeInHeader, gcInfoIndex);
   Address result = headerAddress + sizeof(*header);
   ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
   LargeObjectPage* largeObject = new (largeObjectAddress)
       LargeObjectPage(pageMemory, this, allocationSize);
-  ASSERT(header->checkHeader());
+  header->checkHeader();
 
   // Poison the object header and allocationGranularity bytes after the object
   ASAN_POISON_MEMORY_REGION(header, sizeof(*header));
   ASAN_POISON_MEMORY_REGION(largeObject->getAddress() + largeObject->size(),
                             allocationGranularity);
 
   largeObject->link(&m_firstPage);
 
   getThreadState()->heap().heapStats().increaseAllocatedSpace(
       largeObject->size());
@@ skipping 237 matching lines @@
 
 size_t NormalPage::objectPayloadSizeForTesting() {
   size_t objectPayloadSize = 0;
   Address headerAddress = payload();
   markAsSwept();
   ASSERT(headerAddress != payloadEnd());
   do {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(headerAddress);
     if (!header->isFree()) {
-      ASSERT(header->checkHeader());
+      header->checkHeader();
       objectPayloadSize += header->payloadSize();
     }
     ASSERT(header->size() < blinkPagePayloadSize());
     headerAddress += header->size();
     ASSERT(headerAddress <= payloadEnd());
   } while (headerAddress < payloadEnd());
   return objectPayloadSize;
 }
 
 bool NormalPage::isEmpty() {
@@ skipping 295 matching lines @@
     ASSERT(mapIndex > 0);
     byte = m_objectStartBitMap[--mapIndex];
   }
   int leadingZeroes = numberOfLeadingZeroes(byte);
   objectStartNumber = (mapIndex * 8) + 7 - leadingZeroes;
   objectOffset = objectStartNumber * allocationGranularity;
   Address objectAddress = objectOffset + payload();
   HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(objectAddress);
   if (header->isFree())
     return nullptr;
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   return header;
 }
 
 #if DCHECK_IS_ON()
 static bool isUninitializedMemory(void* objectPointer, size_t objectSize) {
   // Scan through the object's fields and check that they are all zero.
   Address* objectFields = reinterpret_cast<Address*>(objectPointer);
   for (size_t i = 0; i < objectSize / sizeof(Address); ++i) {
     if (objectFields[i] != 0)
       return false;
   }
   return true;
 }
 #endif
 
 static void markPointer(Visitor* visitor, HeapObjectHeader* header) {
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   const GCInfo* gcInfo = ThreadHeap::gcInfo(header->gcInfoIndex());
   if (gcInfo->hasVTable() && !vTableInitialized(header->payload())) {
     // We hit this branch when a GC strikes before GarbageCollected<>'s
     // constructor runs.
     //
     // class A : public GarbageCollected<A> { virtual void f() = 0; };
     // class B : public A {
     //   B() : A(foo()) { };
     // };
     //
@@ skipping 218 matching lines @@
 
   m_hasEntries = true;
   size_t index = hash(address);
   ASSERT(!(index & 1));
   Address cachePage = roundToBlinkPageStart(address);
   m_entries[index + 1] = m_entries[index];
   m_entries[index] = cachePage;
 }
 
 }  // namespace blink