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

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

 /*
  * 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 211 matching lines @@
   void mark();
   void unmark();
 
   Address payload();
   size_t payloadSize();
   Address payloadEnd();
 
   // TODO(633030): Make |checkHeader| and |zapMagic| private. This class should
   // manage its integrity on its own, without requiring outside callers to
   // explicitly check.
-  bool checkHeader() const;
+  void checkHeader() const;
 
 #if DCHECK_IS_ON() && CPU(64BIT)
   // Zap |m_magic| with a new magic number that means there was once an object
   // allocated here, but it was freed because nobody marked it during GC.
   void zapMagic();
 #endif
 
   void finalize(Address, size_t);
   static HeapObjectHeader* fromPayload(const void*);
 
@@ skipping 588 matching lines @@
 
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::size() const {
   size_t result = m_encoded & headerSizeMask;
   // Large objects should not refer to header->size(). The actual size of a
   // large object is stored in |LargeObjectPage::m_payloadSize|.
   ASSERT(result != largeObjectSizeInHeader);
   ASSERT(!pageFromObject(this)->isLargeObjectPage());
   return result;
 }
 
-NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::checkHeader() const {
+NO_SANITIZE_ADDRESS inline void HeapObjectHeader::checkHeader() const {
 #if CPU(64BIT)
-  return m_magic == getMagic();
-#else
-  return true;
+  const bool good = getMagic() == m_magic;
+  DCHECK(good);
 #endif
 }
 
 inline Address HeapObjectHeader::payload() {
   return reinterpret_cast<Address>(this) + sizeof(HeapObjectHeader);
 }
 
 inline Address HeapObjectHeader::payloadEnd() {
   return reinterpret_cast<Address>(this) + size();
 }
 
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::payloadSize() {
   size_t size = m_encoded & headerSizeMask;
   if (UNLIKELY(size == largeObjectSizeInHeader)) {
     ASSERT(pageFromObject(this)->isLargeObjectPage());
     return static_cast<LargeObjectPage*>(pageFromObject(this))->payloadSize();
   }
   ASSERT(!pageFromObject(this)->isLargeObjectPage());
   return size - sizeof(HeapObjectHeader);
 }
 
 inline HeapObjectHeader* HeapObjectHeader::fromPayload(const void* payload) {
   Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
   HeapObjectHeader* header =
       reinterpret_cast<HeapObjectHeader*>(addr - sizeof(HeapObjectHeader));
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   return header;
 }
 
 #if CPU(64BIT)
 ALWAYS_INLINE uint32_t RotateLeft16(uint32_t x) {
 #if COMPILER(MSVC)
   return _lrotr(x, 16);
 #else
   // http://blog.regehr.org/archives/1063
   return (x << 16) | (x >> (-16 & 31));
@@ skipping 39 matching lines @@
 #if COMPILER(MSVC)
 #pragma warning(pop)
 #endif
 
   return random;
 }
 #endif  // CPU(64BIT)
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isWrapperHeaderMarked()
     const {
-  ASSERT(checkHeader());
+  checkHeader();
   return m_encoded & headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::markWrapperHeader() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(!isWrapperHeaderMarked());
   m_encoded |= headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::unmarkWrapperHeader() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(isWrapperHeaderMarked());
   m_encoded &= ~headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isMarked() const {
-  ASSERT(checkHeader());
+  checkHeader();
   return m_encoded & headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::mark() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(!isMarked());
   m_encoded = m_encoded | headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::unmark() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(isMarked());
   m_encoded &= ~headerMarkBitMask;
 }
 
 inline Address NormalPageArena::allocateObject(size_t allocationSize,
                                                size_t gcInfoIndex) {
   if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
     Address headerAddress = m_currentAllocationPoint;
     m_currentAllocationPoint += allocationSize;
     m_remainingAllocationSize -= allocationSize;
     ASSERT(gcInfoIndex > 0);
     new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
     Address result = headerAddress + sizeof(HeapObjectHeader);
     ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
     SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
     ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
     return result;
   }
   return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 inline NormalPageArena* NormalPage::arenaForNormalPage() const {
   return static_cast<NormalPageArena*>(arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h