OLD | NEW |
1 // Copyright 2014 Google Inc. All Rights Reserved. | 1 // Copyright 2014 Google Inc. All Rights Reserved. |
2 // | 2 // |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | 3 // Licensed under the Apache License, Version 2.0 (the "License"); |
4 // you may not use this file except in compliance with the License. | 4 // you may not use this file except in compliance with the License. |
5 // You may obtain a copy of the License at | 5 // You may obtain a copy of the License at |
6 // | 6 // |
7 // http://www.apache.org/licenses/LICENSE-2.0 | 7 // http://www.apache.org/licenses/LICENSE-2.0 |
8 // | 8 // |
9 // Unless required by applicable law or agreed to in writing, software | 9 // Unless required by applicable law or agreed to in writing, software |
10 // distributed under the License is distributed on an "AS IS" BASIS, | 10 // distributed under the License is distributed on an "AS IS" BASIS, |
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
12 // See the License for the specific language governing permissions and | 12 // See the License for the specific language governing permissions and |
13 // limitations under the License. | 13 // limitations under the License. |
14 | 14 |
15 #include "syzygy/agent/asan/shadow_marker.h" | 15 #include "syzygy/agent/asan/shadow_marker.h" |
16 | 16 |
17 #include "base/logging.h" | 17 #include "base/logging.h" |
18 | 18 |
19 namespace agent { | 19 namespace agent { |
20 namespace asan { | 20 namespace asan { |
21 | 21 |
22 namespace { | 22 namespace { |
23 | 23 |
24 // Some constants related to the structure of shadow marker values. | 24 // Some constants related to the structure of shadow marker values. |
25 static const uint8_t kActiveBit = 0x20; | 25 static const uint8_t kActiveBit = 0x20; |
26 static const uint8_t kBlockEndNestedBit = 0x01; | |
27 static const uint8_t kBlockStartDataMask = 0x7; | 26 static const uint8_t kBlockStartDataMask = 0x7; |
28 static const uint8_t kBlockStartNestedBit = 0x08; | |
29 static const uint8_t kFirstNibble = 0xF0; | 27 static const uint8_t kFirstNibble = 0xF0; |
30 static const uint8_t kRedzoneBit = 0x80; | 28 static const uint8_t kRedzoneBit = 0x80; |
31 | 29 |
32 // ShadowMarker name generator. This maps an enumeration value to a name via | 30 // ShadowMarker name generator. This maps an enumeration value to a name via |
33 // template specialization. | 31 // template specialization. |
34 template<size_t kIndex> struct ShadowMarkerNameGenerator { | 32 template<size_t kIndex> struct ShadowMarkerNameGenerator { |
35 static const uintptr_t kName = 0; | 33 static const uintptr_t kName = 0; |
36 }; | 34 }; |
37 #define SHADOW_MARKER_NAME_GENERATOR_MACRO(name, value) \ | 35 #define SHADOW_MARKER_NAME_GENERATOR_MACRO(name, value) \ |
38 template<> struct ShadowMarkerNameGenerator<value> { \ | 36 template<> struct ShadowMarkerNameGenerator<value> { \ |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 | 99 |
102 bool ShadowMarkerHelper::IsHistoricBlockStart(ShadowMarkerValue marker) { | 100 bool ShadowMarkerHelper::IsHistoricBlockStart(ShadowMarkerValue marker) { |
103 return (marker.value & kFirstNibble) == kHeapHistoricBlockStartMarker0; | 101 return (marker.value & kFirstNibble) == kHeapHistoricBlockStartMarker0; |
104 } | 102 } |
105 | 103 |
106 bool ShadowMarkerHelper::IsBlockStart(ShadowMarkerValue marker) { | 104 bool ShadowMarkerHelper::IsBlockStart(ShadowMarkerValue marker) { |
107 static const uint8_t kMask = kFirstNibble ^ kActiveBit; | 105 static const uint8_t kMask = kFirstNibble ^ kActiveBit; |
108 return (marker.value & kMask) == kHeapHistoricBlockStartMarker0; | 106 return (marker.value & kMask) == kHeapHistoricBlockStartMarker0; |
109 } | 107 } |
110 | 108 |
111 bool ShadowMarkerHelper::IsNestedBlockStart(ShadowMarkerValue marker) { | |
112 if (!IsBlockStart(marker)) | |
113 return false; | |
114 return (marker.value & kBlockStartNestedBit) == kBlockStartNestedBit; | |
115 } | |
116 | |
117 uint8_t ShadowMarkerHelper::GetBlockStartData(ShadowMarkerValue marker) { | 109 uint8_t ShadowMarkerHelper::GetBlockStartData(ShadowMarkerValue marker) { |
118 return marker.value & kBlockStartDataMask; | 110 return marker.value & kBlockStartDataMask; |
119 } | 111 } |
120 | 112 |
121 bool ShadowMarkerHelper::IsActiveBlockEnd(ShadowMarkerValue marker) { | 113 bool ShadowMarkerHelper::IsActiveBlockEnd(ShadowMarkerValue marker) { |
122 return (marker.value & ~kBlockEndNestedBit) == | 114 return marker.value == kHeapBlockEndMarker; |
123 kHeapBlockEndMarker; | |
124 } | 115 } |
125 | 116 |
126 bool ShadowMarkerHelper::IsHistoricBlockEnd(ShadowMarkerValue marker) { | 117 bool ShadowMarkerHelper::IsHistoricBlockEnd(ShadowMarkerValue marker) { |
127 return (marker.value & ~kBlockEndNestedBit) == | 118 return marker.value == kHeapHistoricBlockEndMarker; |
128 kHeapHistoricBlockEndMarker; | |
129 } | 119 } |
130 | 120 |
131 bool ShadowMarkerHelper::IsBlockEnd(ShadowMarkerValue marker) { | 121 bool ShadowMarkerHelper::IsBlockEnd(ShadowMarkerValue marker) { |
132 // Block end markers have arbitrary values for the active bit | 122 // Block end markers have an arbitrary value for the active bit. |
133 // and the block end nested bit. | 123 static const uint8_t kMask = static_cast<uint8_t>(~kActiveBit); |
134 static const uint8_t kMask = | |
135 static_cast<uint8_t>(~(kActiveBit | kBlockEndNestedBit)); | |
136 return (marker.value & kMask) == kHeapHistoricBlockEndMarker; | 124 return (marker.value & kMask) == kHeapHistoricBlockEndMarker; |
137 } | 125 } |
138 | 126 |
139 bool ShadowMarkerHelper::IsNestedBlockEnd(ShadowMarkerValue marker) { | |
140 if (!IsBlockEnd(marker)) | |
141 return false; | |
142 return (marker.value & kBlockEndNestedBit) == kBlockEndNestedBit; | |
143 } | |
144 | |
145 bool ShadowMarkerHelper::IsHistoricLeftRedzone(ShadowMarkerValue marker) { | 127 bool ShadowMarkerHelper::IsHistoricLeftRedzone(ShadowMarkerValue marker) { |
146 return marker.value == kHeapHistoricLeftPaddingMarker || | 128 return marker.value == kHeapHistoricLeftPaddingMarker || |
147 IsHistoricBlockStart(marker); | 129 IsHistoricBlockStart(marker); |
148 } | 130 } |
149 | 131 |
150 bool ShadowMarkerHelper::IsActiveLeftRedzone(ShadowMarkerValue marker) { | 132 bool ShadowMarkerHelper::IsActiveLeftRedzone(ShadowMarkerValue marker) { |
151 return marker.value == kHeapLeftPaddingMarker || | 133 return marker.value == kHeapLeftPaddingMarker || |
152 IsActiveBlockStart(marker); | 134 IsActiveBlockStart(marker); |
153 } | 135 } |
154 | 136 |
(...skipping 16 matching lines...) Expand all Loading... |
171 return (marker.value & ~kActiveBit) == kHeapHistoricRightPaddingMarker || | 153 return (marker.value & ~kActiveBit) == kHeapHistoricRightPaddingMarker || |
172 IsBlockEnd(marker); | 154 IsBlockEnd(marker); |
173 } | 155 } |
174 | 156 |
175 ShadowMarker ShadowMarkerHelper::ToHistoric(ShadowMarkerValue marker) { | 157 ShadowMarker ShadowMarkerHelper::ToHistoric(ShadowMarkerValue marker) { |
176 DCHECK(IsActiveBlock(marker)); | 158 DCHECK(IsActiveBlock(marker)); |
177 return static_cast<ShadowMarker>(marker.value & ~kActiveBit); | 159 return static_cast<ShadowMarker>(marker.value & ~kActiveBit); |
178 } | 160 } |
179 | 161 |
180 ShadowMarker ShadowMarkerHelper::BuildBlockStart(bool active, | 162 ShadowMarker ShadowMarkerHelper::BuildBlockStart(bool active, |
181 bool nested, | |
182 uint8_t data) { | 163 uint8_t data) { |
183 DCHECK_EQ(0, data & ~kBlockStartDataMask); | 164 DCHECK_EQ(0, data & ~kBlockStartDataMask); |
184 uint8_t marker = kHeapHistoricBlockStartMarker0; | 165 uint8_t marker = kHeapHistoricBlockStartMarker0; |
185 if (active) | 166 if (active) |
186 marker |= kActiveBit; | 167 marker |= kActiveBit; |
187 if (nested) | |
188 marker |= kBlockStartNestedBit; | |
189 marker |= data; | 168 marker |= data; |
190 return static_cast<ShadowMarker>(marker); | 169 return static_cast<ShadowMarker>(marker); |
191 } | 170 } |
192 | 171 |
193 ShadowMarker ShadowMarkerHelper::BuildBlockEnd(bool active, bool nested) { | 172 ShadowMarker ShadowMarkerHelper::BuildBlockEnd(bool active) { |
194 uint8_t marker = kHeapHistoricBlockEndMarker; | 173 uint8_t marker = kHeapHistoricBlockEndMarker; |
195 if (active) | 174 if (active) |
196 marker |= kActiveBit; | 175 marker |= kActiveBit; |
197 if (nested) | |
198 marker |= kBlockEndNestedBit; | |
199 return static_cast<ShadowMarker>(marker); | 176 return static_cast<ShadowMarker>(marker); |
200 } | 177 } |
201 | 178 |
202 } // namespace asan | 179 } // namespace asan |
203 } // namespace agent | 180 } // namespace agent |
OLD | NEW |