Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 1 | //===-- memtag.h ------------------------------------------------*- C++ -*-===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | |
| 9 | #ifndef SCUDO_MEMTAG_H_ |
| 10 | #define SCUDO_MEMTAG_H_ |
| 11 | |
| 12 | #include "internal_defs.h" |
| 13 | |
| 14 | #if SCUDO_LINUX |
| 15 | #include <sys/auxv.h> |
| 16 | #include <sys/prctl.h> |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 17 | #endif |
| 18 | |
| 19 | namespace scudo { |
| 20 | |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 21 | #if defined(__aarch64__) || defined(SCUDO_FUZZ) |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 22 | |
Peter Collingbourne | cc3d493 | 2020-12-21 18:39:03 -0800 | [diff] [blame] | 23 | // We assume that Top-Byte Ignore is enabled if the architecture supports memory |
| 24 | // tagging. Not all operating systems enable TBI, so we only claim architectural |
| 25 | // support for memory tagging if the operating system enables TBI. |
Peter Collingbourne | 6f816d1 | 2021-03-16 11:46:31 -0700 | [diff] [blame] | 26 | #if SCUDO_LINUX && !defined(SCUDO_DISABLE_TBI) |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 27 | inline constexpr bool archSupportsMemoryTagging() { return true; } |
Peter Collingbourne | cc3d493 | 2020-12-21 18:39:03 -0800 | [diff] [blame] | 28 | #else |
| 29 | inline constexpr bool archSupportsMemoryTagging() { return false; } |
| 30 | #endif |
| 31 | |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 32 | inline constexpr uptr archMemoryTagGranuleSize() { return 16; } |
| 33 | |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 34 | inline uptr untagPointer(uptr Ptr) { return Ptr & ((1ULL << 56) - 1); } |
| 35 | |
Kostya Kortchinsky | a51a892 | 2020-11-02 14:27:11 -0800 | [diff] [blame] | 36 | inline uint8_t extractTag(uptr Ptr) { return (Ptr >> 56) & 0xf; } |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 37 | |
| 38 | #else |
| 39 | |
| 40 | inline constexpr bool archSupportsMemoryTagging() { return false; } |
| 41 | |
| 42 | inline uptr archMemoryTagGranuleSize() { |
| 43 | UNREACHABLE("memory tagging not supported"); |
| 44 | } |
| 45 | |
| 46 | inline uptr untagPointer(uptr Ptr) { |
| 47 | (void)Ptr; |
| 48 | UNREACHABLE("memory tagging not supported"); |
| 49 | } |
| 50 | |
| 51 | inline uint8_t extractTag(uptr Ptr) { |
| 52 | (void)Ptr; |
| 53 | UNREACHABLE("memory tagging not supported"); |
| 54 | } |
| 55 | |
| 56 | #endif |
| 57 | |
| 58 | #if defined(__aarch64__) |
| 59 | |
Roland McGrath | 2699c68 | 2021-01-05 11:55:11 -0800 | [diff] [blame] | 60 | #if SCUDO_LINUX |
| 61 | |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 62 | inline bool systemSupportsMemoryTagging() { |
Peter Collingbourne | 9ece409 | 2020-12-17 21:02:01 -0800 | [diff] [blame] | 63 | #ifndef HWCAP2_MTE |
| 64 | #define HWCAP2_MTE (1 << 18) |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 65 | #endif |
Peter Collingbourne | 9ece409 | 2020-12-17 21:02:01 -0800 | [diff] [blame] | 66 | return getauxval(AT_HWCAP2) & HWCAP2_MTE; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | inline bool systemDetectsMemoryTagFaultsTestOnly() { |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 70 | #ifndef PR_SET_TAGGED_ADDR_CTRL |
| 71 | #define PR_SET_TAGGED_ADDR_CTRL 54 |
| 72 | #endif |
Peter Collingbourne | 9ece409 | 2020-12-17 21:02:01 -0800 | [diff] [blame] | 73 | #ifndef PR_GET_TAGGED_ADDR_CTRL |
| 74 | #define PR_GET_TAGGED_ADDR_CTRL 56 |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 75 | #endif |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 76 | #ifndef PR_TAGGED_ADDR_ENABLE |
| 77 | #define PR_TAGGED_ADDR_ENABLE (1UL << 0) |
| 78 | #endif |
Peter Collingbourne | 9ece409 | 2020-12-17 21:02:01 -0800 | [diff] [blame] | 79 | #ifndef PR_MTE_TCF_SHIFT |
| 80 | #define PR_MTE_TCF_SHIFT 1 |
| 81 | #endif |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 82 | #ifndef PR_MTE_TAG_SHIFT |
| 83 | #define PR_MTE_TAG_SHIFT 3 |
| 84 | #endif |
Peter Collingbourne | 9ece409 | 2020-12-17 21:02:01 -0800 | [diff] [blame] | 85 | #ifndef PR_MTE_TCF_NONE |
| 86 | #define PR_MTE_TCF_NONE (0UL << PR_MTE_TCF_SHIFT) |
| 87 | #endif |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 88 | #ifndef PR_MTE_TCF_SYNC |
| 89 | #define PR_MTE_TCF_SYNC (1UL << PR_MTE_TCF_SHIFT) |
| 90 | #endif |
Peter Collingbourne | 9ece409 | 2020-12-17 21:02:01 -0800 | [diff] [blame] | 91 | #ifndef PR_MTE_TCF_MASK |
| 92 | #define PR_MTE_TCF_MASK (3UL << PR_MTE_TCF_SHIFT) |
| 93 | #endif |
| 94 | return (static_cast<unsigned long>( |
| 95 | prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0)) & |
| 96 | PR_MTE_TCF_MASK) != PR_MTE_TCF_NONE; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 97 | } |
| 98 | |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 99 | inline void enableSystemMemoryTaggingTestOnly() { |
| 100 | prctl(PR_SET_TAGGED_ADDR_CTRL, |
| 101 | PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC | (0xfffe << PR_MTE_TAG_SHIFT), |
| 102 | 0, 0, 0); |
| 103 | } |
| 104 | |
Roland McGrath | 2699c68 | 2021-01-05 11:55:11 -0800 | [diff] [blame] | 105 | #else // !SCUDO_LINUX |
| 106 | |
| 107 | inline bool systemSupportsMemoryTagging() { return false; } |
| 108 | |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 109 | inline bool systemDetectsMemoryTagFaultsTestOnly() { |
| 110 | UNREACHABLE("memory tagging not supported"); |
| 111 | } |
| 112 | |
| 113 | inline void enableSystemMemoryTaggingTestOnly() { |
| 114 | UNREACHABLE("memory tagging not supported"); |
| 115 | } |
Roland McGrath | 2699c68 | 2021-01-05 11:55:11 -0800 | [diff] [blame] | 116 | |
| 117 | #endif // SCUDO_LINUX |
| 118 | |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 119 | class ScopedDisableMemoryTagChecks { |
Vitaly Buka | ac28f8f | 2021-05-22 22:55:53 -0700 | [diff] [blame] | 120 | uptr PrevTCO; |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 121 | |
Kostya Kortchinsky | a51a892 | 2020-11-02 14:27:11 -0800 | [diff] [blame] | 122 | public: |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 123 | ScopedDisableMemoryTagChecks() { |
Roland McGrath | 12ee7ad | 2021-04-13 15:03:54 -0700 | [diff] [blame] | 124 | __asm__ __volatile__( |
| 125 | R"( |
| 126 | .arch_extension memtag |
| 127 | mrs %0, tco |
| 128 | msr tco, #1 |
| 129 | )" |
| 130 | : "=r"(PrevTCO)); |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | ~ScopedDisableMemoryTagChecks() { |
Roland McGrath | 12ee7ad | 2021-04-13 15:03:54 -0700 | [diff] [blame] | 134 | __asm__ __volatile__( |
| 135 | R"( |
| 136 | .arch_extension memtag |
| 137 | msr tco, %0 |
| 138 | )" |
| 139 | : |
| 140 | : "r"(PrevTCO)); |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 141 | } |
| 142 | }; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 143 | |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 144 | inline uptr selectRandomTag(uptr Ptr, uptr ExcludeMask) { |
Vitaly Buka | ef0e354 | 2021-05-28 02:08:44 -0700 | [diff] [blame] | 145 | ExcludeMask |= 1; // Always exclude Tag 0. |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 146 | uptr TaggedPtr; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 147 | __asm__ __volatile__( |
Roland McGrath | 12ee7ad | 2021-04-13 15:03:54 -0700 | [diff] [blame] | 148 | R"( |
| 149 | .arch_extension memtag |
| 150 | irg %[TaggedPtr], %[Ptr], %[ExcludeMask] |
| 151 | )" |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 152 | : [TaggedPtr] "=r"(TaggedPtr) |
| 153 | : [Ptr] "r"(Ptr), [ExcludeMask] "r"(ExcludeMask)); |
| 154 | return TaggedPtr; |
| 155 | } |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 156 | |
Vitaly Buka | 98975bb | 2021-05-24 13:12:47 -0700 | [diff] [blame] | 157 | inline uptr addFixedTag(uptr Ptr, uptr Tag) { |
| 158 | DCHECK_LT(Tag, 16); |
Vitaly Buka | ecf52a7 | 2021-05-24 21:40:44 -0700 | [diff] [blame^] | 159 | DCHECK_EQ(untagPointer(Ptr), Ptr); |
Vitaly Buka | 98975bb | 2021-05-24 13:12:47 -0700 | [diff] [blame] | 160 | return Ptr | (Tag << 56); |
| 161 | } |
Peter Collingbourne | cc3d493 | 2020-12-21 18:39:03 -0800 | [diff] [blame] | 162 | |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 163 | inline uptr storeTags(uptr Begin, uptr End) { |
Vitaly Buka | 98975bb | 2021-05-24 13:12:47 -0700 | [diff] [blame] | 164 | DCHECK_EQ(0, Begin % 16); |
Peter Collingbourne | 71756e6 | 2021-04-20 14:53:41 -0700 | [diff] [blame] | 165 | uptr LineSize, Next, Tmp; |
| 166 | __asm__ __volatile__( |
| 167 | R"( |
| 168 | .arch_extension memtag |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 169 | |
Peter Collingbourne | 71756e6 | 2021-04-20 14:53:41 -0700 | [diff] [blame] | 170 | // Compute the cache line size in bytes (DCZID_EL0 stores it as the log2 |
| 171 | // of the number of 4-byte words) and bail out to the slow path if DCZID_EL0 |
| 172 | // indicates that the DC instructions are unavailable. |
| 173 | DCZID .req %[Tmp] |
| 174 | mrs DCZID, dczid_el0 |
| 175 | tbnz DCZID, #4, 3f |
| 176 | and DCZID, DCZID, #15 |
| 177 | mov %[LineSize], #4 |
| 178 | lsl %[LineSize], %[LineSize], DCZID |
| 179 | .unreq DCZID |
| 180 | |
| 181 | // Our main loop doesn't handle the case where we don't need to perform any |
| 182 | // DC GZVA operations. If the size of our tagged region is less than |
| 183 | // twice the cache line size, bail out to the slow path since it's not |
| 184 | // guaranteed that we'll be able to do a DC GZVA. |
| 185 | Size .req %[Tmp] |
| 186 | sub Size, %[End], %[Cur] |
| 187 | cmp Size, %[LineSize], lsl #1 |
| 188 | b.lt 3f |
| 189 | .unreq Size |
| 190 | |
| 191 | LineMask .req %[Tmp] |
| 192 | sub LineMask, %[LineSize], #1 |
| 193 | |
| 194 | // STZG until the start of the next cache line. |
| 195 | orr %[Next], %[Cur], LineMask |
| 196 | 1: |
| 197 | stzg %[Cur], [%[Cur]], #16 |
| 198 | cmp %[Cur], %[Next] |
| 199 | b.lt 1b |
| 200 | |
| 201 | // DC GZVA cache lines until we have no more full cache lines. |
| 202 | bic %[Next], %[End], LineMask |
| 203 | .unreq LineMask |
| 204 | 2: |
| 205 | dc gzva, %[Cur] |
| 206 | add %[Cur], %[Cur], %[LineSize] |
| 207 | cmp %[Cur], %[Next] |
| 208 | b.lt 2b |
| 209 | |
| 210 | // STZG until the end of the tagged region. This loop is also used to handle |
| 211 | // slow path cases. |
| 212 | 3: |
| 213 | cmp %[Cur], %[End] |
| 214 | b.ge 4f |
| 215 | stzg %[Cur], [%[Cur]], #16 |
| 216 | b 3b |
| 217 | |
| 218 | 4: |
| 219 | )" |
| 220 | : [Cur] "+&r"(Begin), [LineSize] "=&r"(LineSize), [Next] "=&r"(Next), |
| 221 | [Tmp] "=&r"(Tmp) |
| 222 | : [End] "r"(End) |
| 223 | : "memory"); |
Vitaly Buka | 98975bb | 2021-05-24 13:12:47 -0700 | [diff] [blame] | 224 | DCHECK_EQ(0, Begin % 16); |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 225 | return Begin; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 226 | } |
| 227 | |
Peter Collingbourne | 34c8857 | 2021-04-20 14:54:32 -0700 | [diff] [blame] | 228 | inline void storeTag(uptr Ptr) { |
Vitaly Buka | 98975bb | 2021-05-24 13:12:47 -0700 | [diff] [blame] | 229 | DCHECK_EQ(0, Ptr % 16); |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 230 | __asm__ __volatile__(R"( |
Roland McGrath | 3c3951e | 2021-02-03 19:28:29 -0800 | [diff] [blame] | 231 | .arch_extension memtag |
Peter Collingbourne | 34c8857 | 2021-04-20 14:54:32 -0700 | [diff] [blame] | 232 | stg %0, [%0] |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 233 | )" |
Peter Collingbourne | 34c8857 | 2021-04-20 14:54:32 -0700 | [diff] [blame] | 234 | : |
| 235 | : "r"(Ptr) |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 236 | : "memory"); |
| 237 | } |
| 238 | |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 239 | inline uptr loadTag(uptr Ptr) { |
Vitaly Buka | 98975bb | 2021-05-24 13:12:47 -0700 | [diff] [blame] | 240 | DCHECK_EQ(0, Ptr % 16); |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 241 | uptr TaggedPtr = Ptr; |
Roland McGrath | 12ee7ad | 2021-04-13 15:03:54 -0700 | [diff] [blame] | 242 | __asm__ __volatile__( |
| 243 | R"( |
| 244 | .arch_extension memtag |
| 245 | ldg %0, [%0] |
| 246 | )" |
| 247 | : "+r"(TaggedPtr) |
| 248 | : |
| 249 | : "memory"); |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 250 | return TaggedPtr; |
| 251 | } |
| 252 | |
| 253 | #else |
| 254 | |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 255 | inline bool systemSupportsMemoryTagging() { |
| 256 | UNREACHABLE("memory tagging not supported"); |
| 257 | } |
| 258 | |
| 259 | inline bool systemDetectsMemoryTagFaultsTestOnly() { |
| 260 | UNREACHABLE("memory tagging not supported"); |
| 261 | } |
| 262 | |
Vitaly Buka | 58be7da | 2021-05-27 10:10:50 -0700 | [diff] [blame] | 263 | inline void enableSystemMemoryTaggingTestOnly() { |
| 264 | UNREACHABLE("memory tagging not supported"); |
| 265 | } |
| 266 | |
Dynamic Tools Team | 0d7d2ae | 2020-04-21 15:30:50 -0700 | [diff] [blame] | 267 | struct ScopedDisableMemoryTagChecks { |
| 268 | ScopedDisableMemoryTagChecks() {} |
| 269 | }; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 270 | |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 271 | inline uptr selectRandomTag(uptr Ptr, uptr ExcludeMask) { |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 272 | (void)Ptr; |
Peter Collingbourne | 865f674 | 2020-04-30 16:42:17 -0700 | [diff] [blame] | 273 | (void)ExcludeMask; |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 274 | UNREACHABLE("memory tagging not supported"); |
| 275 | } |
| 276 | |
Peter Collingbourne | cc3d493 | 2020-12-21 18:39:03 -0800 | [diff] [blame] | 277 | inline uptr addFixedTag(uptr Ptr, uptr Tag) { |
| 278 | (void)Ptr; |
| 279 | (void)Tag; |
| 280 | UNREACHABLE("memory tagging not supported"); |
| 281 | } |
| 282 | |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 283 | inline uptr storeTags(uptr Begin, uptr End) { |
| 284 | (void)Begin; |
| 285 | (void)End; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 286 | UNREACHABLE("memory tagging not supported"); |
| 287 | } |
| 288 | |
Peter Collingbourne | 34c8857 | 2021-04-20 14:54:32 -0700 | [diff] [blame] | 289 | inline void storeTag(uptr Ptr) { |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 290 | (void)Ptr; |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 291 | UNREACHABLE("memory tagging not supported"); |
| 292 | } |
| 293 | |
| 294 | inline uptr loadTag(uptr Ptr) { |
| 295 | (void)Ptr; |
| 296 | UNREACHABLE("memory tagging not supported"); |
| 297 | } |
| 298 | |
| 299 | #endif |
| 300 | |
Peter Collingbourne | 706ac40 | 2020-12-04 15:03:49 -0800 | [diff] [blame] | 301 | inline void setRandomTag(void *Ptr, uptr Size, uptr ExcludeMask, |
| 302 | uptr *TaggedBegin, uptr *TaggedEnd) { |
| 303 | *TaggedBegin = selectRandomTag(reinterpret_cast<uptr>(Ptr), ExcludeMask); |
| 304 | *TaggedEnd = storeTags(*TaggedBegin, *TaggedBegin + Size); |
| 305 | } |
| 306 | |
Peter Collingbourne | cc3d493 | 2020-12-21 18:39:03 -0800 | [diff] [blame] | 307 | inline void *untagPointer(void *Ptr) { |
| 308 | return reinterpret_cast<void *>(untagPointer(reinterpret_cast<uptr>(Ptr))); |
| 309 | } |
| 310 | |
Peter Collingbourne | 75ee3bc | 2021-01-05 19:03:03 -0800 | [diff] [blame] | 311 | inline void *loadTag(void *Ptr) { |
| 312 | return reinterpret_cast<void *>(loadTag(reinterpret_cast<uptr>(Ptr))); |
| 313 | } |
| 314 | |
| 315 | inline void *addFixedTag(void *Ptr, uptr Tag) { |
| 316 | return reinterpret_cast<void *>( |
| 317 | addFixedTag(reinterpret_cast<uptr>(Ptr), Tag)); |
| 318 | } |
| 319 | |
Peter Collingbourne | 6be4919 | 2020-12-15 14:26:10 -0800 | [diff] [blame] | 320 | template <typename Config> |
| 321 | inline constexpr bool allocatorSupportsMemoryTagging() { |
| 322 | return archSupportsMemoryTagging() && Config::MaySupportMemoryTagging; |
| 323 | } |
| 324 | |
Dynamic Tools Team | 48429c7 | 2019-12-04 17:46:15 -0800 | [diff] [blame] | 325 | } // namespace scudo |
| 326 | |
| 327 | #endif |