Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/shadow_marker.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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "syzygy/agent/asan/shadow_marker.h"
 
 #include "base/logging.h"
 
 namespace agent {
 namespace asan {
 
 namespace {
 
 // Some constants related to the structure of shadow marker values.
 static const uint8_t kActiveBit = 0x20;
-static const uint8_t kBlockEndNestedBit = 0x01;

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

I don't feel qualified to review this file.

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

IIRC Chris wrote most of it.

 static const uint8_t kBlockStartDataMask = 0x7;
-static const uint8_t kBlockStartNestedBit = 0x08;
 static const uint8_t kFirstNibble = 0xF0;
 static const uint8_t kRedzoneBit = 0x80;
 
 // ShadowMarker name generator. This maps an enumeration value to a name via
 // template specialization.
 template<size_t kIndex> struct ShadowMarkerNameGenerator {
   static const uintptr_t kName = 0;
 };
 #define SHADOW_MARKER_NAME_GENERATOR_MACRO(name, value)  \
     template<> struct ShadowMarkerNameGenerator<value> {  \
@@ skipping 62 matching lines @@
 
 bool ShadowMarkerHelper::IsHistoricBlockStart(ShadowMarkerValue marker) {
   return (marker.value & kFirstNibble) == kHeapHistoricBlockStartMarker0;
 }
 
 bool ShadowMarkerHelper::IsBlockStart(ShadowMarkerValue marker) {
   static const uint8_t kMask = kFirstNibble ^ kActiveBit;
   return (marker.value & kMask) == kHeapHistoricBlockStartMarker0;
 }
 
-bool ShadowMarkerHelper::IsNestedBlockStart(ShadowMarkerValue marker) {
-  if (!IsBlockStart(marker))
-    return false;
-  return (marker.value & kBlockStartNestedBit) == kBlockStartNestedBit;
-}
-
 uint8_t ShadowMarkerHelper::GetBlockStartData(ShadowMarkerValue marker) {
   return marker.value & kBlockStartDataMask;
 }
 
 bool ShadowMarkerHelper::IsActiveBlockEnd(ShadowMarkerValue marker) {
-  return (marker.value & ~kBlockEndNestedBit) ==
-      kHeapBlockEndMarker;
+  return marker.value == kHeapBlockEndMarker;
 }
 
 bool ShadowMarkerHelper::IsHistoricBlockEnd(ShadowMarkerValue marker) {
-  return (marker.value & ~kBlockEndNestedBit) ==
-      kHeapHistoricBlockEndMarker;
+  return marker.value == kHeapHistoricBlockEndMarker;
 }
 
 bool ShadowMarkerHelper::IsBlockEnd(ShadowMarkerValue marker) {
-  // Block end markers have arbitrary values for the active bit
-  // and the block end nested bit.
-  static const uint8_t kMask =
-      static_cast<uint8_t>(~(kActiveBit | kBlockEndNestedBit));
+  // Block end markers have an arbitrary value for the active bit.
+  static const uint8_t kMask = static_cast<uint8_t>(~kActiveBit);
   return (marker.value & kMask) == kHeapHistoricBlockEndMarker;
 }
 
-bool ShadowMarkerHelper::IsNestedBlockEnd(ShadowMarkerValue marker) {
-  if (!IsBlockEnd(marker))
-    return false;
-  return (marker.value & kBlockEndNestedBit) == kBlockEndNestedBit;
-}
-
 bool ShadowMarkerHelper::IsHistoricLeftRedzone(ShadowMarkerValue marker) {
   return marker.value == kHeapHistoricLeftPaddingMarker ||
       IsHistoricBlockStart(marker);
 }
 
 bool ShadowMarkerHelper::IsActiveLeftRedzone(ShadowMarkerValue marker) {
   return marker.value == kHeapLeftPaddingMarker ||
       IsActiveBlockStart(marker);
 }
 
@@ skipping 16 matching lines @@
   return (marker.value & ~kActiveBit) == kHeapHistoricRightPaddingMarker ||
       IsBlockEnd(marker);
 }
 
 ShadowMarker ShadowMarkerHelper::ToHistoric(ShadowMarkerValue marker) {
   DCHECK(IsActiveBlock(marker));
   return static_cast<ShadowMarker>(marker.value & ~kActiveBit);
 }
 
 ShadowMarker ShadowMarkerHelper::BuildBlockStart(bool active,
-                                                 bool nested,
                                                  uint8_t data) {
   DCHECK_EQ(0, data & ~kBlockStartDataMask);
   uint8_t marker = kHeapHistoricBlockStartMarker0;
   if (active)
     marker |= kActiveBit;
-  if (nested)
-    marker |= kBlockStartNestedBit;
   marker |= data;
   return static_cast<ShadowMarker>(marker);
 }
 
-ShadowMarker ShadowMarkerHelper::BuildBlockEnd(bool active, bool nested) {
+ShadowMarker ShadowMarkerHelper::BuildBlockEnd(bool active) {
   uint8_t marker = kHeapHistoricBlockEndMarker;
   if (active)
     marker |= kActiveBit;
-  if (nested)
-    marker |= kBlockEndNestedBit;
   return static_cast<ShadowMarker>(marker);
 }
 
 }  // namespace asan
 }  // namespace agent