Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/block.cc

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 32 matching lines @@
 DECLARE_GET_MAX_BITFIELD_VALUE_FUNCTION(BlockHeader, body_size);
 #undef DECLARE_GET_MAX_BITFIELD_VALUE_FUNCTION
 
 const size_t kMaxBlockHeaderBodySize = GetMaxValueBlockHeader_body_size();
 
 void InitializeBlockHeader(BlockInfo* block_info) {
   DCHECK_NE(static_cast<BlockInfo*>(NULL), block_info);
   DCHECK_NE(static_cast<BlockHeader*>(NULL), block_info->header);
   ::memset(block_info->header, 0, sizeof(BlockHeader));
   block_info->header->magic = kBlockHeaderMagic;
-  block_info->header->is_nested = block_info->is_nested;
   block_info->header->has_header_padding = block_info->header_padding_size > 0;
   block_info->header->has_excess_trailer_padding =
       block_info->trailer_padding_size > sizeof(uint32_t);
   block_info->header->state = ALLOCATED_BLOCK;
   block_info->header->body_size = block_info->body_size;
 }
 
 void InitializeBlockHeaderPadding(BlockInfo* block_info) {
   DCHECK_NE(static_cast<BlockInfo*>(NULL), block_info);
   if (block_info->header_padding_size == 0)
@@ skipping 116 matching lines @@
   BlockTrailer* trailer = reinterpret_cast<BlockTrailer*>(
       body + header->body_size + trailer_padding_size);
   if (!IsAligned(reinterpret_cast<uintptr_t>(trailer + 1), kShadowRatio))
     return false;
 
   block_info->header = header;
   block_info->block_size = reinterpret_cast<uint8_t*>(trailer + 1) -
                            reinterpret_cast<uint8_t*>(header);
   block_info->header_size = sizeof(BlockHeader) + header_padding_size;
   block_info->trailer_size = trailer_padding_size + sizeof(BlockTrailer);
-  block_info->is_nested = header->is_nested;
 
   return true;
 }
 
 BlockHeader* BlockGetHeaderFromBodyImpl(const BlockBody* const_body) {
   DCHECK_NE(static_cast<BlockBody*>(nullptr), const_body);
 
   void* body = const_cast<BlockBody*>(const_body);
 
   // The header must be appropriately aligned.
@@ skipping 80 matching lines @@
   layout->header_size = sizeof(BlockHeader);
   layout->header_padding_size = left_redzone_size - sizeof(BlockHeader);
   layout->body_size = size;
   layout->trailer_padding_size = right_redzone_size - sizeof(BlockTrailer);
   layout->trailer_size = sizeof(BlockTrailer);
   return true;
 }
 
 void BlockInitialize(const BlockLayout& layout,
                      void* allocation,
-                     bool is_nested,
                      BlockInfo* block_info) {
   DCHECK_NE(static_cast<void*>(NULL), allocation);
   DCHECK(IsAligned(reinterpret_cast<uintptr_t>(allocation),
                    layout.block_alignment));
 
   // If no output structure is provided then use a local one. We need the data
   // locally, but the caller might not be interested in it.
   BlockInfo local_block_info = {};
   if (block_info == NULL) {
     block_info = &local_block_info;
   } else {
     ::memset(block_info, 0, sizeof(BlockInfo));
   }
 
   // Get pointers to the various components of the block.
   uint8_t* cursor = reinterpret_cast<uint8_t*>(allocation);
   block_info->block_size = layout.block_size;
-  block_info->is_nested = is_nested;
   block_info->header = reinterpret_cast<BlockHeader*>(cursor);
   cursor += sizeof(BlockHeader);
   block_info->header_padding = reinterpret_cast<BlockHeaderPadding*>(cursor);
   cursor += layout.header_padding_size;
   block_info->header_padding_size = layout.header_padding_size;
   block_info->body = reinterpret_cast<BlockBody*>(cursor);
   cursor += layout.body_size;
   block_info->body_size = layout.body_size;
   block_info->trailer_padding = reinterpret_cast<BlockTrailerPadding*>(cursor);
   cursor += layout.trailer_padding_size;
   block_info->trailer_padding_size = layout.trailer_padding_size;
   block_info->trailer = reinterpret_cast<BlockTrailer*>(cursor);
 
-  // Indicates if the block is nested.
-  block_info->is_nested = is_nested;
-
   // If the block information is being returned to the user then determine
   // the extents of whole pages within it.
   if (block_info != &local_block_info)
     BlockIdentifyWholePages(block_info);
 
   // Initialize the various portions of the memory. The body is not initialized
   // as this is an unnecessary performance hit.
   InitializeBlockHeader(block_info);
   InitializeBlockHeaderPadding(block_info);
   InitializeBlockTrailerPadding(block_info);
@@ skipping 27 matching lines @@
   expanded->header_padding = reinterpret_cast<BlockHeaderPadding*>(
       block + sizeof(BlockHeader));
   expanded->body = reinterpret_cast<BlockBody*>(block + compact.header_size);
   expanded->body_size = compact.block_size - compact.header_size -
       compact.trailer_size;
   expanded->trailer_padding_size = compact.trailer_size - sizeof(BlockTrailer);
   expanded->trailer_padding = reinterpret_cast<BlockTrailerPadding*>(
       block + compact.header_size + expanded->body_size);
   expanded->trailer = reinterpret_cast<BlockTrailer*>(
       expanded->RawTrailerPadding() + expanded->trailer_padding_size);
-  expanded->is_nested = compact.is_nested;
   BlockIdentifyWholePages(expanded);
 }
 
 void ConvertBlockInfo(const BlockInfo& expanded, CompactBlockInfo* compact) {
   DCHECK_NE(static_cast<CompactBlockInfo*>(nullptr), compact);
   compact->header = expanded.header;
   compact->block_size = expanded.block_size;
   compact->header_size = static_cast<uint32_t>(sizeof(BlockHeader) +
                                                expanded.header_padding_size);
   compact->trailer_size = static_cast<uint32_t>(sizeof(BlockTrailer) +
                                                 expanded.trailer_padding_size);
-  compact->is_nested = expanded.is_nested;
 }
 
 bool BlockInfoFromMemory(const BlockHeader* header, BlockInfo* block_info) {
   DCHECK_NE(static_cast<BlockHeader*>(nullptr), header);
   DCHECK_NE(static_cast<BlockInfo*>(NULL), block_info);
   CompactBlockInfo compact = {};
   if (!BlockInfoFromMemory(header, &compact))
     return false;
   ConvertBlockInfo(compact, block_info);
   return true;
@@ skipping 70 matching lines @@
     if (block_info.RawBody(i) != kBlockFloodFillByte)
       return false;
   }
   return true;
 }
 
 // Identifies whole pages in the given block_info.
 void BlockIdentifyWholePages(BlockInfo* block_info) {
   DCHECK_NE(static_cast<BlockInfo*>(NULL), block_info);
   static const size_t kPageInfoSize =
-      FIELD_OFFSET(BlockInfo, is_nested) -
-      FIELD_OFFSET(BlockInfo, block_pages);
+      sizeof(BlockInfo) - FIELD_OFFSET(BlockInfo, block_pages);

[Sigurður Ásgeirsson, 2016/11/22 19:15:37]

I'm not sure this is right - how about field_offset(last member) +
sizeof(last_member)?

[Sébastien Marchand, 2016/11/22 22:12:23]

"sizeof(BlockInfo) - FIELD_OFFSET(BlockInfo, block_pages)" was working fine
because |is_nested| used to be the last field of the struct (and so
sizeof(BlockInfo) is now equal to what ELD_OFFSET(BlockInfo, is_nested) was
evaluating to), but your suggestion is probably safer.

 
   if (block_info->block_size < GetPageSize()) {
     ::memset(&block_info->block_pages, 0, kPageInfoSize);
     return;
   }
 
   uintptr_t alloc_start = reinterpret_cast<uintptr_t>(block_info->header);
   uintptr_t alloc_end = alloc_start + block_info->block_size;
   alloc_start = ::common::AlignUp(alloc_start, GetPageSize());
   alloc_end = ::common::AlignDown(alloc_end, GetPageSize());
@@ skipping 251 matching lines @@
   if (!runtime->HeapIdIsValid(heap_id))
     return false;
   return true;
 }
 
 bool BlockHeaderIsConsistent(BlockState block_state,
                              const BlockInfo& block_info) {
   const BlockHeader* h = block_info.header;
   if (h->magic != kBlockHeaderMagic)
     return false;
-  if (static_cast<bool>(h->is_nested) != block_info.is_nested)
-    return false;
 
   bool expect_header_padding = block_info.header_padding_size > 0;
   if (static_cast<bool>(h->has_header_padding) != expect_header_padding)
     return false;
 
   bool expect_excess_trailer_padding =
       block_info.trailer_padding_size > (kShadowRatio / 2);
   if (static_cast<bool>(h->has_excess_trailer_padding) !=
           expect_excess_trailer_padding) {
     return false;
@@ skipping 182 matching lines @@
 void SetOnExceptionCallback(OnExceptionCallback callback) {
   g_on_exception_callback = callback;
 }
 
 void ClearOnExceptionCallback() {
   g_on_exception_callback.Reset();
 }
 
 }  // namespace asan
 }  // namespace agent