Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/block.h

 // 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 94 matching lines @@
 // Various constants for identifying the beginnings of regions of memory.
 static const uint16_t kBlockHeaderMagic = 0xCA80;
 
 // Various constants used for filling regions of memory.
 static const uint8_t kBlockHeaderPaddingByte = 0x1C;
 static const uint8_t kBlockTrailerPaddingByte = 0xC3;
 static const uint8_t kBlockFloodFillByte = 0xFD;
 
 // The number of bits in the checksum field. This is parameterized so that
 // it can be referred to by the checksumming code.
-static const size_t kBlockHeaderChecksumBits = 13;
+static const size_t kBlockHeaderChecksumBits = 14;
 
 // The state of an Asan block. These are in the order that reflects the typical
 // lifespan of an allocation.
 enum BlockState {
   // The block is allocated and valid for reading/writing.
   ALLOCATED_BLOCK,
   // The block has been quarantined, and not valid for reading/writing.
   // While in the quarantine it is still allocated as far as the underlying
   // heap is concerned, and won't be reclaimed.
   QUARANTINED_BLOCK,
@@ skipping 13 matching lines @@
 // overwrites are far more common than underwrites critical information should
 // be stored here.
 #pragma pack(push, 1)
 struct BlockHeader {
   struct {
     // A magic constant that identifies the block header in memory.
     unsigned magic : 16;
     // The checksum of the entire block. The semantics of this vary with the
     // block state.
     unsigned checksum : kBlockHeaderChecksumBits;
-    // If this bit is set then the block is a nested block.
-    unsigned is_nested : 1;
+    // This is implicitly a BlockState value.
+    unsigned state : 2;
     // If this bit is positive then header padding is present. The size of the
     // header padding is encoded in the padding itself.
     unsigned has_header_padding : 1;
     // If this bit is positive then trailer padding in excess of
     // kShadowRatio/2 is present, and the size of the trailer padding itself
     // will be encoded in these bytes. Otherwise it is implicit as
     // (kShadowRatio / 2) - (body_size % (kShadowRatio / 2)).
     unsigned has_excess_trailer_padding : 1;
-    // This is implicitly a BlockState value.
-    unsigned state : 2;
     // The size of the body of the allocation, in bytes.
     unsigned body_size : 30;
   };
   // TODO(loskutov): replace pointers with something more compact.
   // The allocation stack of this block.
   const common::StackCapture* alloc_stack;
   // The free stack of this block (NULL if not yet quarantined/freed).
   const common::StackCapture* free_stack;
 };
 #pragma pack(pop)
@@ skipping 109 matching lines @@
   // strict subset of the entire block, depending on how it was allocated.
   // These pages will have protections toggled as the block changes state.
   // These must stay contiguous.
   uint8_t* block_pages;
   uint32_t block_pages_size;
   uint8_t* left_redzone_pages;
   uint32_t left_redzone_pages_size;
   uint8_t* right_redzone_pages;
   uint32_t right_redzone_pages_size;
 
-  // Indicates if the block is nested.
-  bool is_nested;
-
   // Convenience accessors to various parts of the block. All access should be
   // gated through these as they provide strong bounds checking in debug
   // builds.
   // @name
   // @{
   uint8_t* RawBlock() const { return reinterpret_cast<uint8_t*>(header); }
   uint8_t& RawBlock(uint32_t index) const {
     DCHECK_GT(block_size, index);
     return RawBlock()[index];
   }
@@ skipping 65 matching lines @@
 // Given a fresh allocation and a block layout, lays out and initializes the
 // given block. Initializes everything except for the allocation stack and the
 // checksum. Initializes the block to the ALLOCATED_BLOCK state, setting
 // |alloc_ticks| and |alloc_tid|. Sets |alloc_stack| to NULL; the caller should
 // set this stack upon return so as to minimize the number of useless frames on
 // the stack. Does not set the checksum.
 // @param layout The layout to be respected.
 // @param allocation The allocation to be filled in. This must be of
 //     |layout.block_size| in size, and be aligned with
 //     |layout.block_alignment|.
-// @param is_nested Indicates if the block is nested.
 // @param block_info Will be filled in with pointers to the various portions
 //     of the block. May be NULL.
 // @note The pages containing the block must be writable and readable.
 void BlockInitialize(const BlockLayout& layout,
                      void* allocation,
-                     bool is_nested,
                      BlockInfo* block_info);
 
 // Converts between the two BlockInfo formats. This will work as long as the
 // input is valid; garbage in implies garbage out.
 // @param compact The populated compact block info.
 // @param expanded The full expanded block info.
 void ConvertBlockInfo(const CompactBlockInfo& compact, BlockInfo* expanded);
 void ConvertBlockInfo(const BlockInfo& expanded, CompactBlockInfo* compact);
 
 // Given a pointer to a block examines memory and extracts the block layout.
@@ skipping 129 matching lines @@
 typedef base::Callback<void(EXCEPTION_POINTERS*)> OnExceptionCallback;
 void SetOnExceptionCallback(OnExceptionCallback callback);
 void ClearOnExceptionCallback();
 
 }  // namespace asan
 }  // namespace agent
 
 #include "syzygy/agent/asan/block_impl.h"
 
 #endif  // SYZYGY_AGENT_ASAN_BLOCK_H_