Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/shadow_marker.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 60 matching lines @@
     /* (0x20) disabled. Thus any marker starting with 0xc0 is a historic */  \
     /* block start marker. */  \
     F(kHeapHistoricBlockStartMarker0, 0xC0)  \
     F(kHeapHistoricBlockStartMarker1, 0xC1)  \
     F(kHeapHistoricBlockStartMarker2, 0xC2)  \
     F(kHeapHistoricBlockStartMarker3, 0xC3)  \
     F(kHeapHistoricBlockStartMarker4, 0xC4)  \
     F(kHeapHistoricBlockStartMarker5, 0xC5)  \
     F(kHeapHistoricBlockStartMarker6, 0xC6)  \
     F(kHeapHistoricBlockStartMarker7, 0xC7)  \
-    /* Nested block start bytes have the bit 0x80 set. */  \
-    F(kHeapHistoricNestedBlockStartMarker0, 0xC8)  \
-    F(kHeapHistoricNestedBlockStartMarker1, 0xC9)  \
-    F(kHeapHistoricNestedBlockStartMarker2, 0xCA)  \
-    F(kHeapHistoricNestedBlockStartMarker3, 0xCB)  \
-    F(kHeapHistoricNestedBlockStartMarker4, 0xCC)  \
-    F(kHeapHistoricNestedBlockStartMarker5, 0xCD)  \
-    F(kHeapHistoricNestedBlockStartMarker6, 0xCE)  \
-    F(kHeapHistoricNestedBlockStartMarker7, 0xCF)  \
     /* These are 'historic' markers associated with block left/right */  \
     /* redzones and freed data. They consist of the same values as the */  \
     /* active markers, minus the active block bit. */  \
     F(kHeapHistoricBlockEndMarker, 0xD4)  \
-    F(kHeapHistoricNestedBlockEndMarker, 0xD5)  \
     F(kHeapHistoricLeftPaddingMarker, 0xDA)  \
     F(kHeapHistoricRightPaddingMarker, 0xDB)  \
     F(kHeapHistoricFreedMarker, 0xDD)  \
     /* Any marker starting with 0xe0 marks the beginning of a block. The */  \
     /* trailing 4 bits of the marker are used to encode additional */  \
     /* metadata about the block itself. This is necessary to allow */  \
     /* full introspection of blocks via the shadow. All 'active' block */  \
     /* start bytes have the bit 0x20 set. */  \
     F(kHeapBlockStartMarker0, 0xE0)  \
     F(kHeapBlockStartMarker1, 0xE1)  \
     F(kHeapBlockStartMarker2, 0xE2)  \
     F(kHeapBlockStartMarker3, 0xE3)  \
     F(kHeapBlockStartMarker4, 0xE4)  \
     F(kHeapBlockStartMarker5, 0xE5)  \
     F(kHeapBlockStartMarker6, 0xE6)  \
     F(kHeapBlockStartMarker7, 0xE7)  \
-    /* Nested block start bytes have the bit 0x80 set. */  \
-    F(kHeapNestedBlockStartMarker0, 0xE8)  \
-    F(kHeapNestedBlockStartMarker1, 0xE9)  \
-    F(kHeapNestedBlockStartMarker2, 0xEA)  \
-    F(kHeapNestedBlockStartMarker3, 0xEB)  \
-    F(kHeapNestedBlockStartMarker4, 0xEC)  \
-    F(kHeapNestedBlockStartMarker5, 0xED)  \
-    F(kHeapNestedBlockStartMarker6, 0xEE)  \
-    F(kHeapNestedBlockStartMarker7, 0xEF)  \
     /* The data in this block maps to internal memory structures. */  \
     F(kAsanMemoryMarker, 0xF1)  \
     /* The address covered by this byte are simply invalid and unable to */  \
     /* be accessed by user code. */  \
     F(kInvalidAddressMarker, 0xF2)  \
     /* The bytes are part of a block that has been allocated by the */  \
     /* instrumented code, but subsequently redzoned via the runtime API. */  \
     F(kUserRedzoneMarker, 0xF3)  \
     /* This marker marks the end of a block in memory, and is part of a */  \
     /* right redzone. */  \
     F(kHeapBlockEndMarker, 0xF4)  \
-    F(kHeapNestedBlockEndMarker, 0xF5)  \
     /* The bytes are part of a left redzone (block header padding). */  \
     /* This is the same value as used by Asan itself. */  \
     F(kHeapLeftPaddingMarker, 0xFA)  \
     /* The bytes are part of a right redzone (block trailer and padding). */  \
     /* This is the same value as used by Asan itself. */  \
     F(kHeapRightPaddingMarker, 0xFB)  \
     /* These bytes are part of memory that is destined to be used by the */  \
     /* heap, has been reserved from the OS, but not yet handed out to */  \
     /* the code under test. */  \
     F(kAsanReservedMarker, 0xFC)  \
@@ skipping 61 matching lines @@
   // @param marker The shadow marker to query.
   // @returns true if the marker describes a historic block start marker.
   static bool IsHistoricBlockStart(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
   // @returns true if the marker describes a block header marker, historic or
   //     active.
   static bool IsBlockStart(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
-  // @returns true if the markers describes a nested block start marker,
-  //     historic or active.
-  static bool IsNestedBlockStart(ShadowMarkerValue marker);
-
-  // @param marker The shadow marker to query.
   // @returns the extra data encoded in a block start marker.
   // @note This should only be called for block start markers.
   static uint8_t GetBlockStartData(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
   // @returns true if the marker describes an active block start marker.
   static bool IsActiveBlockEnd(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
   // @returns true if the marker describes a historic block start marker.
   static bool IsHistoricBlockEnd(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
   // @returns true if the marker describes a block header marker, historic or
   //     active.
   static bool IsBlockEnd(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
-  // @returns true if the markers describes a nested block end marker,
-  //     historic or active.
-  static bool IsNestedBlockEnd(ShadowMarkerValue marker);
-
-  // @param marker The shadow marker to query.
   // @returns true if the marker describes a historic left redzone.
   //     Note that block start markers are part of a left redzone.
   static bool IsHistoricLeftRedzone(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
   // @returns true if the marker describes an active left redzone.
   //     Note that block start markers are part of a left redzone.
   static bool IsActiveLeftRedzone(ShadowMarkerValue marker);
 
   // @param marker The shadow marker to query.
@@ skipping 27 matching lines @@
   //     equivalent historic type.
    static ShadowMarker ToHistoric(ShadowMarkerValue marker);
 
   // @}
 
   // @name For building shadow markers.
   // @{
 
   // Builds a block start marker.
   // @param active True if the block is active, false if its historic.
-  // @param nested True if the block is nested, false otherwise.
   // @param data The data to be appended to the marker. This can only consist
   //     of 3 bits of data.
   // @returns the generated block start marker.
-   static ShadowMarker BuildBlockStart(bool active, bool nested, uint8_t data);
+  static ShadowMarker BuildBlockStart(bool active, uint8_t data);
 
   // Builds a block end marker.
   // @param active True if the block is active, false if its historic.
-  // @param nested True if the block is nested, false otherwise.
   // @returns the generated block end marker.
-  static ShadowMarker BuildBlockEnd(bool active, bool nested);
+  static ShadowMarker BuildBlockEnd(bool active);
 
   // @}
 };
 
 }  // namespace asan
 }  // namespace agent
 
 #endif  // SYZYGY_AGENT_ASAN_SHADOW_MARKER_H_