Investigation of porting scudo standalone to Windows for use in LLVM tools.

[FlameTop]

Summary

• For information only. No review needed **

Following our work detailed in D86694 to port the scudo sanitizer lib…rary to Windows, we have investigated also producing a Windows port of the stand-alone version of scudo.

The main impetus for this work was to see if stand-alone scudo (scudo-sa) would scale better on machines with a high number of cores vs the standard Microsoft heap library (MSHeap). We have seen that Thin LTO builds on machines with a high number of cores do not fully utilize the available compute resources.
This makes use of the CRT allocation hooks from D71786.
The new files 'WindowsMMap.h/c' are based on the versions from compiler-rt/lib/profile.
To build with scudo on Windows use: -DLLVM_INTEGRATED_CRT_ALLOC=path to hostlib build -DLLVM_USE_CRT_RELEASE=MT.
Limitations:
• A bug in the MSVC STL implementation means that Debug builds will not work correctly with scudo-sa (STL hard codes calls to MSVC debug heap routines causing attempts to ‘free’ from heap memory allocated by scudo-sa).
• The llvm-rtdly code will not reliably work in 32-bit mode (built for IA64) with scudo-sa. It assumes that any heap blocks will be within a 32-bit address range (as it uses 32-bit relocations between the blocks). Scudo-sa deliberately randomizes the range of addresses returned by heap allocations and frequently returns blocks greater than 4gb apart. (https://bugs.llvm.org/show_bug.cgi?id=24978)
• Some scudo-sa tests assume the presence of ‘pthread’. These have not been ported to Windows.
• Scudo-sa CMAKE build not integrated into parent LLVM build yet.
To evaluate the comparative performance between MSHeap and scudo-sa we performed a ThinLTO build of clang.exe on a 16 core, 32 Hyper Thread based AMD ryzen machine. Running the build with 32 threads showed that MSHeap stopped using all CPU resources at around 16 threads (CPU usage peaked oscillating between 15 and 17 threads). Scudo-sa performed the same build using all 32 threads at 100% usage.
Results:
hyperfine.exe -w 1 -m 2 ".\stage1s\lld-link.exe @response.txt /threads:32" ".\stage1\lld-link.exe @response.txt /threads:32"
Benchmark #1: .\stage1s\lld-link.exe @response.txt /threads:32
Time (mean ± σ): 211.857 s ± 3.079 s [User: 7.4 ms, System: 13.2 ms]
Range (min … max): 209.680 s … 214.034 s 2 runs

Benchmark #2: .\stage1\lld-link.exe @response.txt /threads:32
Time (mean ± σ): 233.617 s ± 8.573 s [User: 0.0 ms, System: 13.2 ms]
Range (min … max): 227.555 s … 239.679 s 2 runs

Summary
'.\stage1s\lld-link.exe @response.txt /threads:32' ran
1.10 ± 0.04 times faster than '.\stage1\lld-link.exe @response.txt /threads:32'

(stage1s is scudo-sa build, stage1 MSHeap)

This showed a roughly 10% build speed improvement when using scudo-sa. This is disappointing but understandable as the other 16 threads fully used by scudo-sa are virtual Hyper Thread cores, not true CPU cores.
For builds on smaller machines with less than 16 cores, both MSHeap and scudo-sa utilize 100% of available threads.

hyperfine.exe -w 1 -m 2 ".\stage1s\lld-link.exe @response.txt /threads:12" ".\stage1\lld-link.exe @response.txt /threads:12"
Benchmark #1: .\stage1s\lld-link.exe @response.txt /threads:12
Time (mean ± σ): 259.826 s ± 0.055 s [User: 7.5 ms, System: 7.0 ms]
Range (min … max): 259.787 s … 259.865 s 2 runs

Benchmark #2: .\stage1\lld-link.exe @response.txt /threads:12
Time (mean ± σ): 245.082 s ± 0.386 s [User: 7.5 ms, System: 0.0 ms]
Range (min … max): 244.809 s … 245.354 s 2 runs

Summary
'.\stage1\lld-link.exe @response.txt /threads:12' ran
1.06 ± 0.00 times faster than '.\stage1s\lld-link.exe @response.txt /threads:12'

In this case MSHeap is slightly quicker than scudo-sa.
Given the results we have seen, we will not be spending any further time investigating scudo-sa as a replacement for the default Microsoft heap.

[FlameTop]

Fixed missing commit in diff file.

[aganea]

Thanks a lot for working on this!

I'm a bit surprised by the results. I expected a much better performance with Scudo, when compared with the Windows Heap. Even on a 6-core machine, the perf. is at least 2x better with rpmalloc, than with the Windows Heap. And this improves a lot with the number of cores. @cryptoad was saying that tweeking could be involved to make Scudo optimal.

Generally I still think it would be valuable to go ahead with a Windows port for scudo-sa. @cryptoad seemed to be confident in the fact that the performance of Scudo could match that of other lockfree allocators.

@FlameTop @russell.gallop What would be otherwise the alternative? Should we go ahead with a patch that adds a copy of rpmalloc in the trunk? This was suggested in offline discussions.

[FlameTop]

One of the main problems we found in this investigation was getting reliable performance metrics. Scudo was at least very consistent. Windows Heap appears to be wildly influenced by the allocation/de-allocation profile. In some circumstances WinHeap was seen to perform and scale very well over multiple threads. But in others it was seen to perform amazingly badly. One suspected culprit for this effect is the interaction between the 'low-fragmentation' heap scheme used for smaller allocations vs the 'big heap' for larger.

compiler-rt/lib/scudo/standalone/allocator_config.h

#else
   static const uptr PrimaryRegionSizeLog = 19U;
   typedef uptr PrimaryCompactPtrT;
 #endif
   static const s32 PrimaryMinReleaseToOsIntervalMs = INT32_MIN;
   static const s32 PrimaryMaxReleaseToOsIntervalMs = INT32_MAX;
 
   typedef MapAllocatorCache<DefaultConfig> SecondaryCache;
   static const u32 SecondaryCacheEntriesArraySize = 32U;
+#ifdef _MSC_VER
+  static const u32 SecondaryCacheQuarantineSize = 1U;
+#else
   static const u32 SecondaryCacheQuarantineSize = 0U;
+#endif
   static const u32 SecondaryCacheDefaultMaxEntriesCount = 32U;
   static const uptr SecondaryCacheDefaultMaxEntrySize = 1UL << 19;
   static const s32 SecondaryCacheMinReleaseToOsIntervalMs = INT32_MIN;
   static const s32 SecondaryCacheMaxReleaseToOsIntervalMs = INT32_MAX;
 
   template <class A> using TSDRegistryT = TSDRegistryExT<A>; // Exclusive
 };
+
 struct AndroidConfig {
   using SizeClassMap = AndroidSizeClassMap;
   static const bool MaySupportMemoryTagging = true;
 
 #if SCUDO_CAN_USE_PRIMARY64
   typedef SizeClassAllocator64<AndroidConfig> Primary;
   static const uptr PrimaryRegionSizeLog = 28U;
   typedef u32 PrimaryCompactPtrT;
#endif
   static const uptr SecondaryCacheDefaultMaxEntrySize = 1UL << 18;
   static const s32 SecondaryCacheMinReleaseToOsIntervalMs = 0;
   static const s32 SecondaryCacheMaxReleaseToOsIntervalMs = 0;
 
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 2U, 1U>; // Shared, max 2 TSDs.
 };
 
+struct WindowsConfig {
+  using SizeClassMap = DefaultSizeClassMap;
+  static const bool MaySupportMemoryTagging = false;
+
+#if SCUDO_CAN_USE_PRIMARY64
+  typedef SizeClassAllocator64<WindowsConfig> Primary;
+  static const uptr PrimaryRegionSizeLog = 33U;
+  typedef uptr PrimaryCompactPtrT;
+  static const uptr PrimaryCompactPtrScale = 0;
+  static const bool PrimaryEnableRandomOffset = true;
+  static const uptr PrimaryMapSizeIncrement = 1UL << 18;
+#else
+  typedef SizeClassAllocator32<WindowsConfig> Primary;
+  static const uptr PrimaryRegionSizeLog = 19U;
+  typedef uptr PrimaryCompactPtrT;
+#endif
+  static const s32 PrimaryMinReleaseToOsIntervalMs = INT32_MIN;
+  static const s32 PrimaryMaxReleaseToOsIntervalMs = INT32_MAX;
+
+  typedef MapAllocatorCache<WindowsConfig> SecondaryCache;
+  static const u32 SecondaryCacheEntriesArraySize = 32U;
+  static const u32 SecondaryCacheQuarantineSize = 2U; 
+  static const u32 SecondaryCacheDefaultMaxEntriesCount = 32U;
+  static const uptr SecondaryCacheDefaultMaxEntrySize = PTRBIT << 19;
+  static const s32 SecondaryCacheMinReleaseToOsIntervalMs = INT32_MIN;
+  static const s32 SecondaryCacheMaxReleaseToOsIntervalMs = INT32_MAX;
+
+  template <class A>
+  using TSDRegistryT = TSDRegistrySharedT<A, 16U, 16U>; // Shared, max 16 TSDs.
+};
+
 #if SCUDO_CAN_USE_PRIMARY64
 struct FuchsiaConfig {
   using SizeClassMap = FuchsiaSizeClassMap;
   static const bool MaySupportMemoryTagging = false;
 
   typedef SizeClassAllocator64<FuchsiaConfig> Primary;
   static const uptr PrimaryRegionSizeLog = 30U;
   typedef u32 PrimaryCompactPtrT;
struct TrustyConfig {
   typedef MapAllocatorNoCache SecondaryCache;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 1U, 1U>; // Shared, max 1 TSD.
 };
 #endif
 
 #if SCUDO_ANDROID
 typedef AndroidConfig Config;
+#elif SCUDO_WINDOWS
+typedef WindowsConfig Config;
 #elif SCUDO_FUCHSIA
 typedef FuchsiaConfig Config;
 #elif SCUDO_TRUSTY
 typedef TrustyConfig Config;
 #else
 typedef DefaultConfig Config;
 #endif
 
 } // namespace scudo
 
 #endif // SCUDO_ALLOCATOR_CONFIG_H_

compiler-rt/lib/scudo/standalone/atomic_helpers.h

 //===-- atomic_helpers.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_ATOMIC_H_
 #define SCUDO_ATOMIC_H_
 
 #include "internal_defs.h"
 
+#ifdef _WIN32
+#include <windows.h>
+#include <atomic>
+#endif
 namespace scudo {
 
 enum memory_order {
   memory_order_relaxed = 0,
   memory_order_consume = 1,
   memory_order_acquire = 2,
   memory_order_release = 3,
   memory_order_acq_rel = 4,
   memory_order_seq_cst = 5
 };
+#ifndef _MSC_VER 
 static_assert(memory_order_relaxed == __ATOMIC_RELAXED, "");
 static_assert(memory_order_consume == __ATOMIC_CONSUME, "");
 static_assert(memory_order_acquire == __ATOMIC_ACQUIRE, "");
 static_assert(memory_order_release == __ATOMIC_RELEASE, "");
 static_assert(memory_order_acq_rel == __ATOMIC_ACQ_REL, "");
 static_assert(memory_order_seq_cst == __ATOMIC_SEQ_CST, "");
+#endif
 
 struct atomic_u8 {
   typedef u8 Type;
+#ifdef _MSC_VER
+  volatile std::atomic_uint8_t ValDoNotUse;
+#else
   volatile Type ValDoNotUse;
+#endif
 };
 
 struct atomic_u16 {
   typedef u16 Type;
+#ifdef _MSC_VER
+  volatile std::atomic_uint16_t ValDoNotUse;
+#else
   volatile Type ValDoNotUse;
+#endif
 };
 
 struct atomic_s32 {
   typedef s32 Type;
+#ifdef _MSC_VER
+  volatile std::atomic_int32_t ValDoNotUse;
+#else
   volatile Type ValDoNotUse;
+#endif
 };
 
 struct atomic_u32 {
   typedef u32 Type;
+#ifdef _MSC_VER
+  volatile std::atomic_uint32_t ValDoNotUse;
+#else
   volatile Type ValDoNotUse;
+#endif
 };
 
 struct atomic_u64 {
   typedef u64 Type;
   // On 32-bit platforms u64 is not necessarily aligned on 8 bytes.
+#ifdef _MSC_VER
+  volatile std::atomic_uint64_t ValDoNotUse;
+#else
   alignas(8) volatile Type ValDoNotUse;
+#endif
 };
 
 struct atomic_uptr {
   typedef uptr Type;
+#ifdef _MSC_VER
+  volatile std::atomic_uintptr_t ValDoNotUse;
+#else
   volatile Type ValDoNotUse;
+#endif
 };
 
 template <typename T>
 inline typename T::Type atomic_load(const volatile T *A, memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
+#ifdef _MSC_VER
+  return std::atomic_load_explicit(&A->ValDoNotUse, static_cast<std::memory_order>(MO));
+#else
   typename T::Type V;
   __atomic_load(&A->ValDoNotUse, &V, MO);
   return V;
+#endif
 }
 
 template <typename T>
 inline void atomic_store(volatile T *A, typename T::Type V, memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
+#ifdef _MSC_VER
+  std::atomic_store_explicit(&A->ValDoNotUse, V, static_cast<std::memory_order>(MO));
+#else
   __atomic_store(&A->ValDoNotUse, &V, MO);
+#endif
 }
 
-inline void atomic_thread_fence(memory_order) { __sync_synchronize(); }
+inline void atomic_thread_fence(memory_order) { 
+#ifdef _AMD64_
+  __faststorefence();
+#elif defined(_IA64_)
+  __mf()
+#elif defined(_MSC_VER)
+  MemoryBarrier();
+#else
+  __sync_synchronize(); 
+#endif
+}
+#ifdef _WIN32
+inline void __atomic_signal_fence(memory_order order) {
+  std::atomic_signal_fence(static_cast<std::memory_order>(order));
+}
+#endif
 
 template <typename T>
 inline typename T::Type atomic_fetch_add(volatile T *A, typename T::Type V,
                                          memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
+#ifdef _MSC_VER
+  return std::atomic_fetch_add_explicit(&A->ValDoNotUse, V, static_cast<std::memory_order>(MO));
+#else
   return __atomic_fetch_add(&A->ValDoNotUse, V, MO);
+#endif
 }
 
 template <typename T>
 inline typename T::Type atomic_fetch_sub(volatile T *A, typename T::Type V,
                                          memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
+#ifdef _MSC_VER
+  return std::atomic_fetch_sub_explicit(&A->ValDoNotUse, V, static_cast<std::memory_order>(MO));
+#else
   return __atomic_fetch_sub(&A->ValDoNotUse, V, MO);
+#endif
 }
 
 template <typename T>
 inline typename T::Type atomic_fetch_and(volatile T *A, typename T::Type V,
                                          memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
+#ifdef _MSC_VER
+  return std::atomic_fetch_and(&A->ValDoNotUse, V);
+#else
   return __atomic_fetch_and(&A->ValDoNotUse, V, MO);
+#endif
 }
 
 template <typename T>
 inline typename T::Type atomic_fetch_or(volatile T *A, typename T::Type V,
                                         memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
+#ifdef _MSC_VER
+  return std::atomic_fetch_or(&A->ValDoNotUse, V);
+#else
   return __atomic_fetch_or(&A->ValDoNotUse, V, MO);
+#endif
 }
 
 template <typename T>
 inline typename T::Type atomic_exchange(volatile T *A, typename T::Type V,
                                         memory_order MO) {
   DCHECK(!(reinterpret_cast<uptr>(A) % sizeof(*A)));
   typename T::Type R;
+#ifdef _MSC_VER
+  R = std::atomic_exchange_explicit(&A->ValDoNotUse, V, static_cast<std::memory_order>(MO));
+#else
   __atomic_exchange(&A->ValDoNotUse, &V, &R, MO);
+#endif
   return R;
 }
 
 template <typename T>
 inline bool atomic_compare_exchange_strong(volatile T *A, typename T::Type *Cmp,
                                            typename T::Type Xchg,
                                            memory_order MO) {
+#ifdef _MSC_VER
+  return std::atomic_compare_exchange_strong(&A->ValDoNotUse, Cmp, Xchg);
+#else
   return __atomic_compare_exchange(&A->ValDoNotUse, Cmp, &Xchg, false, MO,
-                                   __ATOMIC_RELAXED);
+                                   memory_order_relaxed);
+#endif
 }
 
 // Clutter-reducing helpers.
 
 template <typename T>
 inline typename T::Type atomic_load_relaxed(const volatile T *A) {
   return atomic_load(A, memory_order_relaxed);
 }

compiler-rt/lib/scudo/standalone/chunk.h

 
 #include "platform.h"
 
 #include "atomic_helpers.h"
 #include "checksum.h"
 #include "common.h"
 #include "report.h"
 
+#ifdef _WIN32
+#include <intrin.h>
+#endif
+
 namespace scudo {
 
 extern Checksum HashAlgorithm;
 
 inline u16 computeChecksum(u32 Seed, uptr Value, uptr *Array, uptr ArraySize) {
   // If the hardware CRC32 feature is defined here, it was enabled everywhere,
   // as opposed to only for crc32_hw.cpp. This means that other hardware
   // specific instructions were likely emitted at other places, and as a result
   // there is no reason to not use it here.
-#if defined(__SSE4_2__) || defined(__ARM_FEATURE_CRC32)
+#ifdef _WIN32
+  u32 Crc = static_cast<u32>(_mm_crc32_u32(Seed, static_cast<u32>(Value)));
+  for (uptr I = 0; I < ArraySize; I++)
+    Crc = static_cast<u32>(_mm_crc32_u32(Crc, static_cast<u32>(Array[I])));
+  return static_cast<u16>(Crc ^ (Crc >> 16));
+#elif defined(__SSE4_2__) || defined(__ARM_FEATURE_CRC32)
   u32 Crc = static_cast<u32>(CRC32_INTRINSIC(Seed, Value));
   for (uptr I = 0; I < ArraySize; I++)
     Crc = static_cast<u32>(CRC32_INTRINSIC(Crc, Array[I]));
   return static_cast<u16>(Crc ^ (Crc >> 16));
 #else
   if (HashAlgorithm == Checksum::HardwareCRC32) {
     u32 Crc = computeHardwareCRC32(Seed, Value);
     for (uptr I = 0; I < ArraySize; I++)
enum Origin : u8 {
   NewArray = 2,
   Memalign = 3,
 };
 
 enum State : u8 { Available = 0, Allocated = 1, Quarantined = 2 };
 
 typedef u64 PackedHeader;
 // Update the 'Mask' constants to reflect changes in this structure.
+#ifdef _MSC_VER
+#pragma pack(push,1)
+#endif
 struct UnpackedHeader {
+#ifdef _MSC_VER
+  unsigned int ClassId : 8;
+  unsigned int State : 2;
+  unsigned int OriginOrWasZeroed : 2;
+  unsigned int SizeOrUnusedBytes : 20;
+  unsigned int Offset : 16;
+  unsigned int Checksum : 16;
+#else
   uptr ClassId : 8;
   u8 State : 2;
   // Origin if State == Allocated, or WasZeroed otherwise.
   u8 OriginOrWasZeroed : 2;
   uptr SizeOrUnusedBytes : 20;
   uptr Offset : 16;
   uptr Checksum : 16;
+#endif
 };
+#ifdef _MSC_VER
+#pragma pack(pop)
+#endif
 typedef atomic_u64 AtomicPackedHeader;
 static_assert(sizeof(UnpackedHeader) == sizeof(PackedHeader), "");
 
 // Those constants are required to silence some -Werror=conversion errors when
 // assigning values to the related bitfield variables.
-constexpr uptr ClassIdMask = (1UL << 8) - 1;
+constexpr uptr ClassIdMask = (PTRBIT << 8) - 1;
 constexpr u8 StateMask = (1U << 2) - 1;
 constexpr u8 OriginMask = (1U << 2) - 1;
-constexpr uptr SizeOrUnusedBytesMask = (1UL << 20) - 1;
-constexpr uptr OffsetMask = (1UL << 16) - 1;
-constexpr uptr ChecksumMask = (1UL << 16) - 1;
+constexpr uptr SizeOrUnusedBytesMask = (PTRBIT << 20) - 1;
+constexpr uptr OffsetMask = (PTRBIT << 16) - 1;
+constexpr uptr ChecksumMask = (PTRBIT << 16) - 1;
 
 constexpr uptr getHeaderSize() {
-  return roundUpTo(sizeof(PackedHeader), 1U << SCUDO_MIN_ALIGNMENT_LOG);
+  return roundUpTo(sizeof(PackedHeader), PTRBIT << SCUDO_MIN_ALIGNMENT_LOG);
 }
 
 inline AtomicPackedHeader *getAtomicHeader(void *Ptr) {
   return reinterpret_cast<AtomicPackedHeader *>(reinterpret_cast<uptr>(Ptr) -
                                                 getHeaderSize());
 }
 
 inline const AtomicPackedHeader *getConstAtomicHeader(const void *Ptr) {

compiler-rt/lib/scudo/standalone/combined.h

 class Allocator {
 public:
   using PrimaryT = typename Params::Primary;
   using CacheT = typename PrimaryT::CacheT;
   typedef Allocator<Params, PostInitCallback> ThisT;
   typedef typename Params::template TSDRegistryT<ThisT> TSDRegistryT;
 
   void callPostInitCallback() {
+#ifdef _WIN32
+    static pthread_once_t PostInitNonce;
+#else
+    static pthread_once_t PostInitNonce = PTHREAD_ONCE_INIT;
+#endif
     pthread_once(&PostInitNonce, PostInitCallback);
   }
 
   struct QuarantineCallback {
     explicit QuarantineCallback(ThisT &Instance, CacheT &LocalCache)
         : Allocator(Instance), Cache(LocalCache) {}
 
     // Chunk recycling function, returns a quarantined chunk to the backend,
#endif // GWP_ASAN_HOOKS
   }
 
 private:
   using SecondaryT = MapAllocator<Params>;
   typedef typename PrimaryT::SizeClassMap SizeClassMap;
 
   static const uptr MinAlignmentLog = SCUDO_MIN_ALIGNMENT_LOG;
   static const uptr MaxAlignmentLog = 24U; // 16 MB seems reasonable.
-  static const uptr MinAlignment = 1UL << MinAlignmentLog;
-  static const uptr MaxAlignment = 1UL << MaxAlignmentLog;
+  static const uptr MinAlignment = PTRBIT << MinAlignmentLog;
+  static const uptr MaxAlignment = PTRBIT << MaxAlignmentLog;
   static const uptr MaxAllowedMallocSize =
-      FIRST_32_SECOND_64(1UL << 31, 1ULL << 40);
+      FIRST_32_SECOND_64(PTRBIT << 31, PTRBIT << 40);
 
   static_assert(MinAlignment >= sizeof(Chunk::PackedHeader),
                 "Minimal alignment must at least cover a chunk header.");
   static_assert(!allocatorSupportsMemoryTagging<Params>() ||
                     MinAlignment >= archMemoryTagGranuleSize(),
                 "");
 
   static const u32 BlockMarker = 0x44554353U;
 
   // These are indexes into an "array" of 32-bit values that store information
   // inline with a chunk that is relevant to diagnosing memory tag faults, where
   // 0 corresponds to the address of the user memory. This means that only
   // negative indexes may be used. The smallest index that may be used is -2,
   // which corresponds to 8 bytes before the user memory, because the chunk
   // header size is 8 bytes and in allocators that support memory tagging the
   // minimum alignment is at least the tag granule size (16 on aarch64).
   static const sptr MemTagAllocationTraceIndex = -2;
   static const sptr MemTagAllocationTidIndex = -1;
 
-  u32 Cookie = 0;
-  u32 QuarantineMaxChunkSize = 0;
+  u32 Cookie MAYBE_INIT(=0);
+  u32 QuarantineMaxChunkSize MAYBE_INIT(= 0);
 
   GlobalStats Stats;
   PrimaryT Primary;
   SecondaryT Secondary;
   QuarantineT Quarantine;
   TSDRegistryT TSDRegistry;
-  pthread_once_t PostInitNonce = PTHREAD_ONCE_INIT;
+  pthread_once_t PostInitNonce MAYBE_INIT(= PTHREAD_ONCE_INIT);
 
 #ifdef GWP_ASAN_HOOKS
   gwp_asan::GuardedPoolAllocator GuardedAlloc;
-  uptr GuardedAllocSlotSize = 0;
+  uptr GuardedAllocSlotSize MAYBE_INIT(= 0);
 #endif // GWP_ASAN_HOOKS
 
   StackDepot Depot;
 
   struct AllocationRingBuffer {
     struct Entry {
       atomic_uptr Ptr;
       atomic_uptr AllocationSize;
       atomic_u32 AllocationTrace;
       atomic_u32 AllocationTid;
       atomic_u32 DeallocationTrace;
       atomic_u32 DeallocationTid;
     };
 
     atomic_uptr Pos;
 #ifdef SCUDO_FUZZ
     static const uptr NumEntries = 2;
 #else
     static const uptr NumEntries = 32768;
 #endif
     Entry Entries[NumEntries];
   };
-  AllocationRingBuffer RingBuffer = {};
+  AllocationRingBuffer RingBuffer MAYBE_INIT(= {});
 
   // The following might get optimized out by the compiler.
   NOINLINE void performSanityChecks() {
     // Verify that the header offset field can hold the maximum offset. In the
     // case of the Secondary allocator, it takes care of alignment and the
     // offset will always be small. In the case of the Primary, the worst case
     // scenario happens in the last size class, when the backend allocation
     // would already be aligned on the requested alignment, which would happen
     // to be the maximum alignment that would fit in that size class. As a
     // result, the maximum offset will be at most the maximum alignment for the
     // last size class minus the header size, in multiples of MinAlignment.
     Chunk::UnpackedHeader Header = {};
-    const uptr MaxPrimaryAlignment = 1UL << getMostSignificantSetBitIndex(
+    const uptr MaxPrimaryAlignment = PTRBIT << getMostSignificantSetBitIndex(
                                          SizeClassMap::MaxSize - MinAlignment);
     const uptr MaxOffset =
         (MaxPrimaryAlignment - Chunk::getHeaderSize()) >> MinAlignmentLog;
     Header.Offset = MaxOffset & Chunk::OffsetMask;
     if (UNLIKELY(Header.Offset != MaxOffset))
       reportSanityCheckError("offset");
 
     // Verify that we can fit the maximum size or amount of unused bytes in the
if (UNLIKELY(useMemoryTagging<Params>(Options))) {
       if (NewHeader.ClassId) {
         if (!TSDRegistry.getDisableMemInit()) {
           uptr TaggedBegin, TaggedEnd;
           const uptr OddEvenMask = computeOddEvenMaskForPointerMaybe(
               Options, reinterpret_cast<uptr>(getBlockBegin(Ptr, &NewHeader)),
               NewHeader.ClassId);
           // Exclude the previous tag so that immediate use after free is
           // detected 100% of the time.
-          setRandomTag(Ptr, Size, OddEvenMask | (1UL << PrevTag), &TaggedBegin,
+          setRandomTag(Ptr, Size, OddEvenMask | (PTRBIT << PrevTag), &TaggedBegin,
                        &TaggedEnd);
         }
       }
     }
     if (BypassQuarantine) {
       if (allocatorSupportsMemoryTagging<Params>())
         Ptr = untagPointer(Ptr);
       void *BlockBegin = getBlockBegin(Ptr, &NewHeader);

compiler-rt/lib/scudo/standalone/common.h

 //===-- common.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_COMMON_H_
 #define SCUDO_COMMON_H_
 
 #include "internal_defs.h"
 
+#ifdef _MSC_VER
+#include <intrin.h>
+#include <windows.h>
+#define LIKELY(X) (X)
+#define UNLIKELY(X) (X)
+#endif
+
 #include "fuchsia.h"
 #include "linux.h"
+#include "wind.h"
 #include "trusty.h"
 
 #include <stddef.h>
 #include <string.h>
 
 namespace scudo {
 
 template <class Dest, class Source> inline Dest bit_cast(const Source &S) {
   static_assert(sizeof(Dest) == sizeof(Source), "");

 template <class T> void Swap(T &A, T &B) {
   T Tmp = A;
   A = B;
   B = Tmp;
 }
 
 inline bool isPowerOfTwo(uptr X) { return (X & (X - 1)) == 0; }
 
+#ifdef _WIN32
+static inline int __builtin_clz(unsigned x) {
+  return (int)__lzcnt(x);
+}
+
+static inline int __builtin_clzll(unsigned long long x) {
+  return (int)__lzcnt64(x);
+}
+
+static inline int __builtin_clzl(unsigned long long x) {
+  return sizeof(x) == 8 ? __builtin_clzll(x) : __builtin_clz((uint32_t)x);
+}
+#endif
+
 inline uptr getMostSignificantSetBitIndex(uptr X) {
   DCHECK_NE(X, 0U);
-  return SCUDO_WORDSIZE - 1U - static_cast<uptr>(__builtin_clzl(X));
+  return static_cast<uptr>(SCUDO_WORDSIZE - 1U) - static_cast<uptr>(__builtin_clzl(X));
 }
 
 inline uptr roundUpToPowerOfTwo(uptr Size) {
   DCHECK(Size);
   if (isPowerOfTwo(Size))
     return Size;
   const uptr Up = getMostSignificantSetBitIndex(Size);
-  DCHECK_LT(Size, (1UL << (Up + 1)));
-  DCHECK_GT(Size, (1UL << Up));
-  return 1UL << (Up + 1);
+  DCHECK_LT(Size, (PTRBIT << (Up + 1)));
+  DCHECK_GT(Size, (PTRBIT << Up));
+  return PTRBIT << (Up + 1);
+}
+
+#ifdef _WIN32
+static inline int __builtin_ctz(unsigned x) {
+  unsigned long ret;
+  _BitScanForward(&ret, x);
+  return (int)ret;
+}
+
+static inline int __builtin_ctzll(unsigned long long x) {
+  unsigned long ret;
+  _BitScanForward64(&ret, x);
+  return (int)ret;
+}
+
+static inline int __builtin_ctzl(unsigned long long x) {
+  return sizeof(x) == 8 ? __builtin_ctzll(x) : __builtin_ctz((uint32_t)x);
 }
+#endif
 
 inline uptr getLeastSignificantSetBitIndex(uptr X) {
   DCHECK_NE(X, 0U);
   return static_cast<uptr>(__builtin_ctzl(X));
 }
 
 inline uptr getLog2(uptr X) {
   DCHECK(isPowerOfTwo(X));
template <typename T> inline void shuffle(T *A, u32 N, u32 *RandState) {
   for (u32 I = N - 1; I > 0; I--)
     Swap(A[I], A[getRandomModN(&State, I + 1)]);
   *RandState = State;
 }
 
 // Hardware specific inlinable functions.
 
 inline void yieldProcessor(u8 Count) {
-#if defined(__i386__) || defined(__x86_64__)
+#ifdef _MSC_VER
+  for (u8 I = 0; I < Count; I++)
+    YieldProcessor();
+#elif defined(__i386__) || defined(__x86_64__)
   __asm__ __volatile__("" ::: "memory");
   for (u8 I = 0; I < Count; I++)
     __asm__ __volatile__("pause");
+  __asm__ __volatile__("" ::: "memory");
 #elif defined(__aarch64__) || defined(__arm__)
   __asm__ __volatile__("" ::: "memory");
   for (u8 I = 0; I < Count; I++)
     __asm__ __volatile__("yield");
-#endif
   __asm__ __volatile__("" ::: "memory");
+#endif
 }
 
 // Platform specific functions.
 
 extern uptr PageSizeCached;
 uptr getPageSizeSlow();
 inline uptr getPageSizeCached() {
   // Bionic uses a hardcoded value.

compiler-rt/lib/scudo/standalone/crc32_hw.cpp

 //===-- crc32_hw.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "checksum.h"
 
 namespace scudo {
 
-#if defined(__SSE4_2__) || defined(__ARM_FEATURE_CRC32)
+#ifdef _MSC_VER
+#include <intrin.h>
+  u32 computeHardwareCRC32(u32 Crc, uptr Data) {
+    return static_cast<u32>(_mm_crc32_u64(Crc, Data));
+  }
+#elif defined(__SSE4_2__) || defined(__ARM_FEATURE_CRC32)
 u32 computeHardwareCRC32(u32 Crc, uptr Data) {
   return static_cast<u32>(CRC32_INTRINSIC(Crc, Data));
 }
 #endif // defined(__SSE4_2__) || defined(__ARM_FEATURE_CRC32)
 
 } // namespace scudo

compiler-rt/lib/scudo/standalone/hostlib/CMakeLists.txt

+# cmake for host library version of Scudo standalone build
+project(scudo-sa)
+
+cmake_minimum_required(VERSION 3.13.4)
+
+set(CMAKE_GENERATOR_PLATFORM Visual Studio 15 2017)
+
+include_directories(.. ../include)
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
+
+add_library(scudo-sa STATIC
+  ../allocator_config.h
+  ../atomic_helpers.h
+  ../bytemap.h
+  ../checksum.h
+  ../chunk.h
+  ../combined.h
+  ../common.h
+  ../flags_parser.h
+  ../flags.h
+  ../fuchsia.h
+  ../internal_defs.h
+  ../linux.h
+  ../list.h
+  ../local_cache.h
+  ../memtag.h
+  ../mutex.h
+  ../options.h
+  ../platform.h
+  ../primary32.h
+  ../primary64.h
+  ../quarantine.h
+  ../release.h
+  ../report.h
+  ../secondary.h
+  ../size_class_map.h
+  ../stack_depot.h
+  ../stats.h
+  ../string_utils.h
+  ../tsd_exclusive.h
+  ../tsd_shared.h
+  ../tsd.h
+  ../vector.h
+  ../wind.h
+  ../windowsmmap.h
+  ../wrappers_c_checks.h
+  ../wrappers_c.h
+
+  ../include/scudo/interface.h
+
+  ../checksum.cpp
+  ../common.cpp
+  ../crc32_hw.cpp
+  ../flags_parser.cpp
+  ../flags.cpp
+  ../fuchsia.cpp
+  ../linux.cpp
+  ../release.cpp
+  ../report.cpp
+  ../string_utils.cpp
+  ../wind.cpp
+  ../windowsmmap.c
+  ../wrappers_c.cpp
+  ../wrappers_cpp.cpp
+  )
+
+set_property(TARGET scudo-sa PROPERTY CXX_STANDARD 17)
+set_property(TARGET scudo-sa PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded")
+  
+install(TARGETS scudo-sa DESTINATION ../../../../../SIE/lib) 

compiler-rt/lib/scudo/standalone/hostlib/readme.txt

+This directory holds the cmake file(s) for creation of a host library version
+of scudo standalone. 
+
+For Windows10 this can be generated by:
+
+  cmake -G "Visual Studio 15 2017 Win64" -B build
+
+Then using Visual Studio to build the 'scudo-sa.sln' solution found in the
+build directory. 

compiler-rt/lib/scudo/standalone/include/scudo/interface.h

 //===-- scudo/interface.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_INTERFACE_H_
 #define SCUDO_INTERFACE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 extern "C" {
 
-__attribute__((weak)) const char *__scudo_default_options();
+WEAK const char *__scudo_default_options();
 
 // Post-allocation & pre-deallocation hooks.
 // They must be thread-safe and not use heap related functions.
-__attribute__((weak)) void __scudo_allocate_hook(void *ptr, size_t size);
-__attribute__((weak)) void __scudo_deallocate_hook(void *ptr);
+WEAK void __scudo_allocate_hook(void *ptr, size_t size);
+WEAK void __scudo_deallocate_hook(void *ptr);
 
 void __scudo_print_stats(void);
 
 typedef void (*iterate_callback)(uintptr_t base, size_t size, void *arg);
 
 // Determine the likely cause of a tag check fault or other memory protection
 // error on a system with memory tagging support. The results are returned via
 // the error_info data structure. Up to three possible causes are returned in

compiler-rt/lib/scudo/standalone/internal_defs.h

 #include <stdint.h>
 
 #ifndef SCUDO_DEBUG
 #define SCUDO_DEBUG 0
 #endif
 
 #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
 
+// Single bit of correct size for shifting into pointers
+#ifdef _MSC_VER
+#define PTRBIT 1ULL
+#else
+#define PTRBIT 1UL
+#endif
+
 // String related macros.
 
 #define STRINGIFY_(S) #S
 #define STRINGIFY(S) STRINGIFY_(S)
 #define CONCATENATE_(S, C) S##C
 #define CONCATENATE(S, C) CONCATENATE_(S, C)
 
 // Attributes & builtins related macros.
 
+#ifdef __GNUC__ 
 #define INTERFACE __attribute__((visibility("default")))
 #define HIDDEN __attribute__((visibility("hidden")))
 #define WEAK __attribute__((weak))
 #define ALWAYS_INLINE inline __attribute__((always_inline))
 #define ALIAS(X) __attribute__((alias(X)))
 #define FORMAT(F, A) __attribute__((format(printf, F, A)))
 #define NOINLINE __attribute__((noinline))
 #define NORETURN __attribute__((noreturn))

 // scudo::Allocator<>'s constructor as 'constexpr' isn't sufficient to prevent
 // dynamic initialization, as default initialization is fine under 'constexpr'
 // (but not 'constinit'). Clang at -O0, and gcc at all opt levels will emit a
 // dynamic initializer for any constant-initialized variables if there is a mix
 // of default-initialized and constant-initialized variables.
 //
 // If you're looking at this because your build failed, you probably introduced
 // a new member to scudo::Allocator<> (possibly transiently) that didn't have an
-// initializer. The fix is easy - just add one.
+// initializer. The fix is easy - just add one (GNU/clang) or remove (MSVC).
 #if defined(__has_attribute)
 #if __has_attribute(require_constant_initialization)
 #define SCUDO_REQUIRE_CONSTANT_INITIALIZATION                                  \
   __attribute__((__require_constant_initialization__))
 #else
 #define SCUDO_REQUIRE_CONSTANT_INITIALIZATION
 #endif
 #endif
+// for GNU and clang initialization ensures no dynamic initialisation
+#define MAYBE_INIT(x) x
+#else // __GNUC__
+#define WEAK 
+#define ALWAYS_INLINE __forceinline
+#define NORETURN __declspec(noreturn)
+#define NOINLINE __declspec(noinline)
+#define FORMAT(F, A)
+#ifndef UNUSED
+#define UNUSED [[maybe_unused]]
+#endif
+#define NOUNIQUEADDRESS 
+#define INTERFACE
+#define HIDDEN 
+#define PREFETCH(X) (X)
+#define NOEXCEPT noexcept
+#define SCUDO_REQUIRE_CONSTANT_INITIALIZATION 
+// for MSVC no initialization ensures no dynamic initialisation
+#define MAYBE_INIT(x)
+#endif // __GNUC__
 
 namespace scudo {
 
 typedef uintptr_t uptr;
 typedef uint8_t u8;
 typedef uint16_t u16;
 typedef uint32_t u32;
 typedef uint64_t u64;

compiler-rt/lib/scudo/standalone/local_cache.h

private:
   static const uptr BatchClassId = SizeClassMap::BatchClassId;
   struct PerClass {
     u32 Count;
     u32 MaxCount;
     // Note: ClassSize is zero for the transfer batch.
     uptr ClassSize;
     CompactPtrT Chunks[2 * TransferBatch::MaxNumCached];
   };
-  PerClass PerClassArray[NumClasses] = {};
+  PerClass PerClassArray[NumClasses] MAYBE_INIT(= {});
   LocalStats Stats;
-  SizeClassAllocator *Allocator = nullptr;
+  SizeClassAllocator *Allocator MAYBE_INIT( = nullptr);
 
   ALWAYS_INLINE void initCacheMaybe(PerClass *C) {
     if (LIKELY(C->MaxCount))
       return;
     initCache();
     DCHECK_NE(C->MaxCount, 0U);
   }
 

compiler-rt/lib/scudo/standalone/mutex.h

 private:
   static constexpr u8 NumberOfTries = 8U;
   static constexpr u8 NumberOfYields = 8U;
 
 #if SCUDO_LINUX
   atomic_u32 M = {};
 #elif SCUDO_FUCHSIA
   sync_mutex_t M = {};
+#elif SCUDO_WINDOWS
+  atomic_u32 M;
 #endif
 
   void lockSlow();
 };
 
 class ScopedLock {
 public:
   explicit ScopedLock(HybridMutex &M) : Mutex(M) { Mutex.lock(); }

compiler-rt/lib/scudo/standalone/platform.h

 #endif
 
 #if defined(__TRUSTY__)
 #define SCUDO_TRUSTY 1
 #else
 #define SCUDO_TRUSTY 0
 #endif
 
-#if __LP64__
+#if defined(_WIN32)
+#define SCUDO_WINDOWS 1
+#else
+#define SCUDO_WINDOWS 0
+#endif
+
+#if __LP64__ || defined(_MSC_VER)
 #define SCUDO_WORDSIZE 64U
 #else
 #define SCUDO_WORDSIZE 32U
 #endif
 
 #if SCUDO_WORDSIZE == 64U
 #define FIRST_32_SECOND_64(a, b) (b)
 #else
 #define FIRST_32_SECOND_64(a, b) (a)
 #endif
 
 #ifndef SCUDO_CAN_USE_PRIMARY64
 #define SCUDO_CAN_USE_PRIMARY64 (SCUDO_WORDSIZE == 64U)
 #endif
 
 #ifndef SCUDO_MIN_ALIGNMENT_LOG
 // We force malloc-type functions to be aligned to std::max_align_t, but there
 // is no reason why the minimum alignment for all other functions can't be 8
 // bytes. Except obviously for applications making incorrect assumptions.
 // TODO(kostyak): define SCUDO_MIN_ALIGNMENT_LOG 3
 #define SCUDO_MIN_ALIGNMENT_LOG FIRST_32_SECOND_64(3, 4)
 #endif
 
 #if defined(__aarch64__)
-#define SCUDO_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48)
+#define SCUDO_MMAP_RANGE_SIZE FIRST_32_SECOND_64(PTRBIT << 32, PTRBIT << 48)
 #else
-#define SCUDO_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
+#define SCUDO_MMAP_RANGE_SIZE FIRST_32_SECOND_64(PTRBIT << 32, PTRBIT << 47)
 #endif
 
 // Older gcc have issues aligning to a constexpr, and require an integer.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56859 among others.
 #if defined(__powerpc__) || defined(__powerpc64__)
 #define SCUDO_CACHE_LINE_SIZE 128
 #else
 #define SCUDO_CACHE_LINE_SIZE 64
 #endif
 
 #define SCUDO_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12)
 
 #endif // SCUDO_PLATFORM_H_

compiler-rt/lib/scudo/standalone/primary32.h

 
 template <typename Config> class SizeClassAllocator32 {
 public:
   typedef typename Config::PrimaryCompactPtrT CompactPtrT;
   typedef typename Config::SizeClassMap SizeClassMap;
   // The bytemap can only track UINT8_MAX - 1 classes.
   static_assert(SizeClassMap::LargestClassId <= (UINT8_MAX - 1), "");
   // Regions should be large enough to hold the largest Block.
-  static_assert((1UL << Config::PrimaryRegionSizeLog) >= SizeClassMap::MaxSize,
+  static_assert((PTRBIT << Config::PrimaryRegionSizeLog) >= SizeClassMap::MaxSize,
                 "");
   typedef SizeClassAllocator32<Config> ThisT;
   typedef SizeClassAllocatorLocalCache<ThisT> CacheT;
   typedef typename CacheT::TransferBatch TransferBatch;
 
   static uptr getSizeByClassId(uptr ClassId) {
     return (ClassId == SizeClassMap::BatchClassId)
                ? sizeof(TransferBatch)
static BlockInfo findNearestBlock(UNUSED const char *RegionInfoData,
                                     UNUSED uptr Ptr) {
     return {};
   }
 
   AtomicOptions Options;
 
 private:
   static const uptr NumClasses = SizeClassMap::NumClasses;
-  static const uptr RegionSize = 1UL << Config::PrimaryRegionSizeLog;
+  static const uptr RegionSize = PTRBIT << Config::PrimaryRegionSizeLog;
   static const uptr NumRegions =
       SCUDO_MMAP_RANGE_SIZE >> Config::PrimaryRegionSizeLog;
   static const u32 MaxNumBatches = SCUDO_ANDROID ? 4U : 8U;
   typedef FlatByteMap<NumRegions> ByteMap;
 
   struct SizeClassStats {
     uptr PoppedBlocks;
     uptr PushedBlocks;

compiler-rt/lib/scudo/standalone/primary64.h

void *decompactPtr(uptr ClassId, CompactPtrT CompactPtr) {
     return reinterpret_cast<void *>(
         decompactPtrInternal(getCompactPtrBaseByClassId(ClassId), CompactPtr));
   }
 
   static BlockInfo findNearestBlock(const char *RegionInfoData, uptr Ptr) {
     const RegionInfo *RegionInfoArray =
         reinterpret_cast<const RegionInfo *>(RegionInfoData);
     uptr ClassId;
-    uptr MinDistance = -1UL;
+    uptr MinDistance = -(PTRBIT);
     for (uptr I = 0; I != NumClasses; ++I) {
       if (I == SizeClassMap::BatchClassId)
         continue;
       uptr Begin = RegionInfoArray[I].RegionBeg;
       uptr End = Begin + RegionInfoArray[I].AllocatedUser;
       if (Begin > End || End - Begin < SizeClassMap::getSizeByClassId(I))
         continue;
       uptr RegionDistance;
if (MinDistance <= 8192) {
         B.BlockBegin -= B.BlockSize;
     }
     return B;
   }
 
   AtomicOptions Options;
 
 private:
-  static const uptr RegionSize = 1UL << Config::PrimaryRegionSizeLog;
+  static const uptr RegionSize = PTRBIT << Config::PrimaryRegionSizeLog;
   static const uptr NumClasses = SizeClassMap::NumClasses;
   static const uptr PrimarySize = RegionSize * NumClasses;
 
   static const uptr MapSizeIncrement = Config::PrimaryMapSizeIncrement;
   // Fill at most this number of batches from the newly map'd memory.
   static const u32 MaxNumBatches = SCUDO_ANDROID ? 4U : 8U;
 
   struct RegionStats {
     uptr PoppedBlocks;
     uptr PushedBlocks;
   };
 
   struct ReleaseToOsInfo {
     uptr PushedBlocksAtLastRelease;
     uptr RangesReleased;
     uptr LastReleasedBytes;
     u64 LastReleaseAtNs;
   };
 
   struct UnpaddedRegionInfo {
     HybridMutex Mutex;
     SinglyLinkedList<TransferBatch> FreeList;
-    uptr RegionBeg = 0;
-    RegionStats Stats = {};
-    u32 RandState = 0;
-    uptr MappedUser = 0;    // Bytes mapped for user memory.
-    uptr AllocatedUser = 0; // Bytes allocated for user memory.
-    MapPlatformData Data = {};
-    ReleaseToOsInfo ReleaseInfo = {};
-    bool Exhausted = false;
+    uptr RegionBeg MAYBE_INIT(= 0);
+    RegionStats Stats MAYBE_INIT(= {});
+    u32 RandState MAYBE_INIT(= 0);
+    uptr MappedUser MAYBE_INIT(= 0);    // Bytes mapped for user memory.
+    uptr AllocatedUser MAYBE_INIT(= 0); // Bytes allocated for user memory.
+    MapPlatformData Data MAYBE_INIT(= {});
+    ReleaseToOsInfo ReleaseInfo MAYBE_INIT(= {});
+    bool Exhausted MAYBE_INIT(= false);
   };
   struct RegionInfo : UnpaddedRegionInfo {
     char Padding[SCUDO_CACHE_LINE_SIZE -
                  (sizeof(UnpaddedRegionInfo) % SCUDO_CACHE_LINE_SIZE)] = {};
   };
   static_assert(sizeof(RegionInfo) % SCUDO_CACHE_LINE_SIZE == 0, "");
 
-  uptr PrimaryBase = 0;
-  MapPlatformData Data = {};
-  atomic_s32 ReleaseToOsIntervalMs = {};
+  uptr PrimaryBase MAYBE_INIT(= 0);
+  MapPlatformData Data MAYBE_INIT(= {});
+  atomic_s32 ReleaseToOsIntervalMs MAYBE_INIT(= {});
   alignas(SCUDO_CACHE_LINE_SIZE) RegionInfo RegionInfoArray[NumClasses];
 
   RegionInfo *getRegionInfo(uptr ClassId) {
     DCHECK_LT(ClassId, NumClasses);
     return &RegionInfoArray[ClassId];
   }
 
   uptr getRegionBaseByClassId(uptr ClassId) const {

compiler-rt/lib/scudo/standalone/quarantine.h

void enable() {
     RecycleMutex.unlock();
   }
 
 private:
   // Read-only data.
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex CacheMutex;
   CacheT Cache;
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex RecycleMutex;
-  atomic_uptr MinSize = {};
-  atomic_uptr MaxSize = {};
-  alignas(SCUDO_CACHE_LINE_SIZE) atomic_uptr MaxCacheSize = {};
+  atomic_uptr MinSize MAYBE_INIT(= {});
+  atomic_uptr MaxSize MAYBE_INIT(= {});
+  alignas(SCUDO_CACHE_LINE_SIZE) atomic_uptr MaxCacheSize MAYBE_INIT(= {});
 
   void NOINLINE recycle(uptr MinSize, Callback Cb) {
     CacheT Tmp;
     Tmp.init();
     {
       ScopedLock L(CacheMutex);
       // Go over the batches and merge partially filled ones to
       // save some memory, otherwise batches themselves (since the memory used

compiler-rt/lib/scudo/standalone/report.cpp

NORETURN ~ScopedErrorReport() {
     setAbortMessage(Message.data());
     die();
   }
 
 private:
   ScopedString Message;
 };
 
-inline void NORETURN trap() { __builtin_trap(); }
+inline void NORETURN trap() {
+#ifdef _MSC_VER
+  __debugbreak();
+#else
+  __builtin_trap();
+#endif
+}
 
 // This could potentially be called recursively if a CHECK fails in the reports.
 void NORETURN reportCheckFailed(const char *File, int Line,
                                 const char *Condition, u64 Value1, u64 Value2) {
   static atomic_u32 NumberOfCalls;
   if (atomic_fetch_add(&NumberOfCalls, 1, memory_order_relaxed) > 2) {
     // TODO(kostyak): maybe sleep here?
     trap();

compiler-rt/lib/scudo/standalone/secondary.h

struct alignas(Max<uptr>(archSupportsMemoryTagging()
                              : 1,
                          1U << SCUDO_MIN_ALIGNMENT_LOG)) Header {
   LargeBlock::Header *Prev;
   LargeBlock::Header *Next;
   uptr CommitBase;
   uptr CommitSize;
   uptr MapBase;
   uptr MapSize;
-  [[no_unique_address]] MapPlatformData Data;
+  NOUNIQUEADDRESS MapPlatformData Data;
 };
 
 static_assert(sizeof(Header) % (1U << SCUDO_MIN_ALIGNMENT_LOG) == 0, "");
 static_assert(!archSupportsMemoryTagging() ||
                   sizeof(Header) % archMemoryTagGranuleSize() == 0,
               "");
 
 constexpr uptr getHeaderSize() { return sizeof(Header); }
void store(Options Options, LargeBlock::Header *H) {
     Entry.CommitBase = H->CommitBase;
     Entry.CommitSize = H->CommitSize;
     Entry.MapBase = H->MapBase;
     Entry.MapSize = H->MapSize;
     Entry.BlockBegin = reinterpret_cast<uptr>(H + 1);
     Entry.Data = H->Data;
     Entry.Time = Time;
     if (useMemoryTagging<Config>(Options)) {
-      if (Interval == 0 && !SCUDO_FUCHSIA) {
+      if (Interval == 0 && !SCUDO_FUCHSIA && !SCUDO_WINDOWS) {
         // Release the memory and make it inaccessible at the same time by
         // creating a new MAP_NOACCESS mapping on top of the existing mapping.
-        // Fuchsia does not support replacing mappings by creating a new mapping
+        // Fuchsia/windows does not support replacing mappings by creating a new mapping
         // on top so we just do the two syscalls there.
         Entry.Time = 0;
         mapSecondary<Config>(Options, Entry.CommitBase, Entry.CommitSize,
                              Entry.CommitBase, MAP_NOACCESS, &Entry.Data);
       } else {
         setMemoryPermission(Entry.CommitBase, Entry.CommitSize, MAP_NOACCESS,
                             &Entry.Data);
       }
     } else if (Interval == 0) {
+#if !SCUDO_WINDOWS
       releasePagesToOS(Entry.CommitBase, 0, Entry.CommitSize, &Entry.Data);
       Entry.Time = 0;
+#endif
     }
     do {
       ScopedLock L(Mutex);
-      if (useMemoryTagging<Config>(Options) && QuarantinePos == -1U) {
+      if (useMemoryTagging<Config>(Options) && QuarantinePos == static_cast<u32>(-1)) {
         // If we get here then memory tagging was disabled in between when we
         // read Options and when we locked Mutex. We can't insert our entry into
         // the quarantine or the cache because the permissions would be wrong so
         // just unmap it.
         break;
       }
       if (Config::SecondaryCacheQuarantineSize &&
           useMemoryTagging<Config>(Options)) {
for (u32 I = 0; I != Config::SecondaryCacheQuarantineSize; ++I) {
         Quarantine[I].CommitBase = 0;
       }
     }
     const u32 MaxCount = atomic_load_relaxed(&MaxEntriesCount);
     for (u32 I = 0; I < MaxCount; I++)
       if (Entries[I].CommitBase)
         setMemoryPermission(Entries[I].CommitBase, Entries[I].CommitSize, 0,
                             &Entries[I].Data);
-    QuarantinePos = -1U;
+    QuarantinePos = static_cast<u32>(-1);
   }
 
   void disable() { Mutex.lock(); }
 
   void enable() { Mutex.unlock(); }
 
   void unmapTestOnly() { empty(); }
 
private:
   }
 
   struct CachedBlock {
     uptr CommitBase;
     uptr CommitSize;
     uptr MapBase;
     uptr MapSize;
     uptr BlockBegin;
-    [[no_unique_address]] MapPlatformData Data;
+    NOUNIQUEADDRESS MapPlatformData Data;
     u64 Time;
   };
 
   void releaseIfOlderThan(CachedBlock &Entry, u64 Time) {
+#if !SCUDO_WINDOWS
     if (!Entry.CommitBase || !Entry.Time)
       return;
     if (Entry.Time > Time) {
       if (OldestTime == 0 || Entry.Time < OldestTime)
         OldestTime = Entry.Time;
       return;
     }
     releasePagesToOS(Entry.CommitBase, 0, Entry.CommitSize, &Entry.Data);
     Entry.Time = 0;
+#endif
   }
 
   void releaseOlderThan(u64 Time) {
+#if !SCUDO_WINDOWS
     ScopedLock L(Mutex);
     if (!EntriesCount || OldestTime == 0 || OldestTime > Time)
       return;
     OldestTime = 0;
     for (uptr I = 0; I < Config::SecondaryCacheQuarantineSize; I++)
       releaseIfOlderThan(Quarantine[I], Time);
     for (uptr I = 0; I < Config::SecondaryCacheEntriesArraySize; I++)
       releaseIfOlderThan(Entries[I], Time);
+#endif
   }
 
   HybridMutex Mutex;
-  u32 EntriesCount = 0;
-  u32 QuarantinePos = 0;
-  atomic_u32 MaxEntriesCount = {};
-  atomic_uptr MaxEntrySize = {};
-  u64 OldestTime = 0;
-  u32 IsFullEvents = 0;
-  atomic_s32 ReleaseToOsIntervalMs = {};
+  u32 EntriesCount MAYBE_INIT(= 0);
+  u32 QuarantinePos MAYBE_INIT(= 0);
+  atomic_u32 MaxEntriesCount MAYBE_INIT(= {});
+  atomic_uptr MaxEntrySize MAYBE_INIT(= {});
+  u64 OldestTime MAYBE_INIT(= 0);
+  u32 IsFullEvents MAYBE_INIT(= 0);
+  atomic_s32 ReleaseToOsIntervalMs MAYBE_INIT(= {});
 
-  CachedBlock Entries[Config::SecondaryCacheEntriesArraySize] = {};
-  CachedBlock Quarantine[Config::SecondaryCacheQuarantineSize] = {};
+  CachedBlock Entries[Config::SecondaryCacheEntriesArraySize] MAYBE_INIT(= {});
+  CachedBlock Quarantine[Config::SecondaryCacheQuarantineSize] MAYBE_INIT(= {});
 };
 
 template <typename Config> class MapAllocator {
 public:
   void init(GlobalStats *S, s32 ReleaseToOsInterval = -1) {
     DCHECK_EQ(AllocatedBytes, 0U);
     DCHECK_EQ(FreedBytes, 0U);
     Cache.init(ReleaseToOsInterval);
public:
 
   void unmapTestOnly() { Cache.unmapTestOnly(); }
 
 private:
   typename Config::SecondaryCache Cache;
 
   HybridMutex Mutex;
   DoublyLinkedList<LargeBlock::Header> InUseBlocks;
-  uptr AllocatedBytes = 0;
-  uptr FreedBytes = 0;
-  uptr LargestSize = 0;
-  u32 NumberOfAllocs = 0;
-  u32 NumberOfFrees = 0;
+  uptr AllocatedBytes MAYBE_INIT(= 0);
+  uptr FreedBytes MAYBE_INIT(= 0);
+  uptr LargestSize MAYBE_INIT(= 0);
+  u32 NumberOfAllocs MAYBE_INIT(= 0);
+  u32 NumberOfFrees MAYBE_INIT(= 0);
   LocalStats Stats;
 };
 
 // As with the Primary, the size passed to this function includes any desired
 // alignment, so that the frontend can align the user allocation. The hint
 // parameter allows us to unmap spurious memory when dealing with larger
 // (greater than a page) alignments on 32-bit platforms.
 // Due to the sparsity of address space available on those platforms, requesting
 // an allocation from the Secondary with a large alignment would end up wasting
 // VA space (even though we are not committing the whole thing), hence the need
 // to trim off some of the reserved space.
 // For allocations requested with an alignment greater than or equal to a page,
 // the committed memory will amount to something close to Size - AlignmentHint
 // (pending rounding and headers).
 template <typename Config>
 void *MapAllocator<Config>::allocate(Options Options, uptr Size, uptr Alignment,
                                      uptr *BlockEndPtr,
                                      FillContentsMode FillContents) {
   if (Options.get(OptionBit::AddLargeAllocationSlack))
-    Size += 1UL << SCUDO_MIN_ALIGNMENT_LOG;
-  Alignment = Max(Alignment, uptr(1U) << SCUDO_MIN_ALIGNMENT_LOG);
+    Size += PTRBIT << SCUDO_MIN_ALIGNMENT_LOG;
+  Alignment = Max(Alignment, PTRBIT << SCUDO_MIN_ALIGNMENT_LOG);
   const uptr PageSize = getPageSizeCached();
   uptr RoundedSize =
       roundUpTo(roundUpTo(Size, Alignment) + LargeBlock::getHeaderSize() +
                     Chunk::getHeaderSize(),
                 PageSize);
   if (Alignment > PageSize)
     RoundedSize += Alignment - PageSize;
 
const uptr CommitSize = H->CommitSize;
     Stats.sub(StatAllocated, CommitSize);
     Stats.sub(StatMapped, H->MapSize);
   }
   Cache.store(Options, H);
 }
 
 template <typename Config>
 void MapAllocator<Config>::getStats(ScopedString *Str) const {
-  Str->append("Stats: MapAllocator: allocated %u times (%zuK), freed %u times "
-              "(%zuK), remains %u (%zuK) max %zuM\n",
-              NumberOfAllocs, AllocatedBytes >> 10, NumberOfFrees,
-              FreedBytes >> 10, NumberOfAllocs - NumberOfFrees,
-              (AllocatedBytes - FreedBytes) >> 10, LargestSize >> 20);
+  Str->append(
+      "Stats: MapAllocator: allocated %zu times (%zuK), freed %zu times "
+      "(%zuK), remains %zu (%zuK) max %zuM\n",
+      NumberOfAllocs, AllocatedBytes >> 10, NumberOfFrees, FreedBytes >> 10,
+      NumberOfAllocs - NumberOfFrees, (AllocatedBytes - FreedBytes) >> 10,
+      LargestSize >> 20);
 }
 
 } // namespace scudo
 
 #endif // SCUDO_SECONDARY_H_

compiler-rt/lib/scudo/standalone/size_class_map.h

 #include "chunk.h"
 #include "common.h"
 #include "string_utils.h"
 
 namespace scudo {
 
 inline uptr scaledLog2(uptr Size, uptr ZeroLog, uptr LogBits) {
   const uptr L = getMostSignificantSetBitIndex(Size);
-  const uptr LBits = (Size >> (L - LogBits)) - (1 << LogBits);
+  const uptr LBits = (Size >> (L - LogBits)) - (PTRBIT << LogBits);
   const uptr HBits = (L - ZeroLog) << LogBits;
   return LBits + HBits;
 }
 
 template <typename Config> struct SizeClassMapBase {
   static u32 getMaxCachedHint(uptr Size) {
     DCHECK_NE(Size, 0);
     u32 N;

 // This class also gives a hint to a thread-caching allocator about the amount
 // of chunks that can be cached per-thread:
 // - MaxNumCachedHint is a hint for the max number of chunks cached per class.
 // - 2^MaxBytesCachedLog is the max number of bytes cached per class.
 template <typename Config>
 class FixedSizeClassMap : public SizeClassMapBase<Config> {
   typedef SizeClassMapBase<Config> Base;
 
-  static const uptr MinSize = 1UL << Config::MinSizeLog;
-  static const uptr MidSize = 1UL << Config::MidSizeLog;
+  static const uptr MinSize = PTRBIT << Config::MinSizeLog;
+  static const uptr MidSize = PTRBIT << Config::MidSizeLog;
   static const uptr MidClass = MidSize / MinSize;
   static const u8 S = Config::NumBits - 1;
-  static const uptr M = (1UL << S) - 1;
+  static const uptr M = (PTRBIT << S) - 1;
 
 public:
   static const u32 MaxNumCachedHint = Config::MaxNumCachedHint;
 
-  static const uptr MaxSize = (1UL << Config::MaxSizeLog) + Config::SizeDelta;
+  static const uptr MaxSize = (PTRBIT << Config::MaxSizeLog) + Config::SizeDelta;
   static const uptr NumClasses =
       MidClass + ((Config::MaxSizeLog - Config::MidSizeLog) << S) + 1;
   static_assert(NumClasses <= 256, "");
   static const uptr LargestClassId = NumClasses - 1;
   static const uptr BatchClassId = 0;
 
   static uptr getSizeByClassId(uptr ClassId) {
     DCHECK_NE(ClassId, BatchClassId);
public:
   }
 };
 
 template <typename Config>
 class TableSizeClassMap : public SizeClassMapBase<Config> {
   typedef SizeClassMapBase<Config> Base;
 
   static const u8 S = Config::NumBits - 1;
-  static const uptr M = (1UL << S) - 1;
+  static const uptr M = (PTRBIT << S) - 1;
   static const uptr ClassesSize =
       sizeof(Config::Classes) / sizeof(Config::Classes[0]);
 
   struct SizeTable {
     constexpr SizeTable() {
       uptr Pos = 1 << Config::MidSizeLog;
       uptr Inc = 1 << (Config::MidSizeLog - S);
       for (uptr i = 0; i != getTableSize(); ++i) {

compiler-rt/lib/scudo/standalone/tsd.h

 //===-- tsd.h ---------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_TSD_H_
 #define SCUDO_TSD_H_
 
 #include "atomic_helpers.h"
 #include "common.h"
 #include "mutex.h"
 
 #include <limits.h> // for PTHREAD_DESTRUCTOR_ITERATIONS
+#ifndef _WIN32
 #include <pthread.h>
+#endif
 
 // With some build setups, this might still not be defined.
 #ifndef PTHREAD_DESTRUCTOR_ITERATIONS
 #define PTHREAD_DESTRUCTOR_ITERATIONS 4
 #endif
 
 namespace scudo {
 

compiler-rt/lib/scudo/standalone/tsd_shared.h

#endif
   static_assert(alignof(TSD<Allocator>) >= 2, "");
 
   ALWAYS_INLINE void setCurrentTSD(TSD<Allocator> *CurrentTSD) {
     *getTlsPtr() &= 1;
     *getTlsPtr() |= reinterpret_cast<uptr>(CurrentTSD);
   }
 
   ALWAYS_INLINE TSD<Allocator> *getCurrentTSD() {
-    return reinterpret_cast<TSD<Allocator> *>(*getTlsPtr() & ~1ULL);
+    return reinterpret_cast<TSD<Allocator> *>(*getTlsPtr() & ~(PTRBIT));
   }
 
   bool setNumberOfTSDs(u32 N) {
     ScopedLock L(MutexTSDs);
     if (N < NumberOfTSDs)
       return false;
     if (N > TSDsArraySize)
       N = TSDsArraySize;
for (u32 I = 0; I < N; I++) {
       }
       if (A == 1)
         CoPrimes[NumberOfCoPrimes++] = I + 1;
     }
     return true;
   }
 
   void setDisableMemInit(bool B) {
-    *getTlsPtr() &= ~1ULL;
-    *getTlsPtr() |= B;
+    *getTlsPtr() &= ~(PTRBIT);
+    *getTlsPtr() |= static_cast<uptr>(B);
   }
 
   NOINLINE void initThread(Allocator *Instance) {
     initOnceMaybe(Instance);
     // Initial context assignment is done in a plain round-robin fashion.
     const u32 Index = atomic_fetch_add(&CurrentIndex, 1U, memory_order_relaxed);
     setCurrentTSD(&TSDs[Index % NumberOfTSDs]);
     Instance->callPostInitCallback();
if (N > 1U) {
         return CandidateTSD;
       }
     }
     // Last resort, stick with the current one.
     CurrentTSD->lock();
     return CurrentTSD;
   }
 
-  atomic_u32 CurrentIndex = {};
-  u32 NumberOfTSDs = 0;
-  u32 NumberOfCoPrimes = 0;
-  u32 CoPrimes[TSDsArraySize] = {};
-  bool Initialized = false;
+  atomic_u32 CurrentIndex MAYBE_INIT(= {});
+  u32 NumberOfTSDs MAYBE_INIT(= 0);
+  u32 NumberOfCoPrimes MAYBE_INIT(= 0);
+  u32 CoPrimes[TSDsArraySize] MAYBE_INIT(= {});
+  bool Initialized MAYBE_INIT(= false);
   HybridMutex Mutex;
   HybridMutex MutexTSDs;
   TSD<Allocator> TSDs[TSDsArraySize];
 };
 
 } // namespace scudo
 
 #endif // SCUDO_TSD_SHARED_H_

compiler-rt/lib/scudo/standalone/wind.h

+//===-- wind.h -------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SCUDO_WIND_H_
+#define SCUDO_WIND_H_
+
+#include "platform.h"
+
+#include <synchapi.h>
+
+#if SCUDO_WINDOWS
+
+typedef INIT_ONCE pthread_once_t;
+#define PTHREAD_ONCE_INIT 0
+#define __ATOMIC_SEQ_CST memory_order_seq_cst
+
+namespace scudo {
+
+// MapPlatformData is unused on Windows, define it as a minimally sized structure.
+struct MapPlatformData {};
+
+// pthread is not supplied on windows
+struct pthread_key_t
+{
+  DWORD key;
+  void (*destructor) (void *);
+  void* val;
+};
+int pthread_once(pthread_once_t * once_control, void(*init_routine) (void));
+int pthread_key_create(pthread_key_t *key, void(*destructor)(void*));
+void *pthread_getspecific(pthread_key_t key);
+int pthread_setspecific(pthread_key_t* key, void *value);
+
+} // namespace scudo
+
+#endif // SCUDO_WINDOWS
+
+#endif // SCUDO_WIND_H_

compiler-rt/lib/scudo/standalone/wind.cpp

+//===-- wind.cpp -----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "platform.h"
+
+#if SCUDO_WINDOWS
+
+#include "atomic_helpers.h"
+#include "common.h"
+#include "mutex.h"
+#include "wind.h"
+
+extern "C" {
+#include "WindowsMMap.h"
+};
+
+#include <cassert>
+#include <stdlib.h>
+#include <sysinfoapi.h>
+#include <cstdio>
+
+namespace scudo {
+
+  uptr getPageSize() { 
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return static_cast<uptr>(si.dwAllocationGranularity); 
+  }
+
+  const char *getEnv(const char *Name) { 
+    char *pValue;
+    size_t len;
+    errno_t err = _dupenv_s(&pValue, &len, Name);
+    if (err) 
+      return NULL;
+    return pValue;    // we leak here?
+    //    return getenv(Name); 
+  }
+
+  u64 getMonotonicTime() {
+    return GetTickCount64() * 1000000ULL;
+  }
+
+  u32 getThreadID() {
+    return GetCurrentThreadId();
+  }
+
+  u32 getNumberOfCPUs() {
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return static_cast<u32>(si.dwNumberOfProcessors);
+  }
+
+  bool getRandom(void *Buffer, uptr Length, UNUSED bool Blocking) {
+    if (!Buffer || !Length || Length > MaxRandomLength)
+      return false;
+    unsigned int* toWrite = static_cast<unsigned int*>(Buffer);
+    while (Length > sizeof(unsigned int)) {
+      *toWrite = rand();
+      toWrite++;
+      Length = Length - sizeof(unsigned int);
+    }
+    return true;
+  }
+
+  int pthread_once(pthread_once_t * once_control, void (*init_routine) (void))
+  {
+    return InitOnceExecuteOnce(once_control, (PINIT_ONCE_FN)init_routine, NULL, NULL);
+  }
+
+  int pthread_key_create(pthread_key_t *key, void(*destructor)(void*))
+  {
+    key->destructor = destructor;
+    key->val = NULL;
+    return 0;
+  }
+  void* pthread_getspecific(pthread_key_t key)
+  {
+    return key.val;
+  }
+  int pthread_setspecific(pthread_key_t* key, void *value)
+  {
+    key->val = static_cast<void*>(value);
+    return 0;
+  }
+
+
+  void outputRaw(const char *Buffer) {
+    (void)std::fputs(Buffer, stderr);
+  };
+
+  void die() { abort(); }
+
+  void *map(void *Addr, uptr Size, UNUSED const char *Name, uptr Flags,
+    UNUSED MapPlatformData *Data) {
+    int MmapFlags = MAP_PRIVATE | MAP_ANONYMOUS;
+    int MmapProt;
+    if (Flags & MAP_NOACCESS) {
+      MmapProt = PROT_NONE;
+    }
+    else {
+      MmapProt = PROT_READ | PROT_WRITE;
+    }
+#if 0
+    if (Addr) {
+      // Currently no scenario for a noaccess mapping with a fixed address.
+      DCHECK_EQ(Flags & MAP_NOACCESS, 0);
+      MmapFlags |= MAP_FIXED;
+    }
+#endif
+    void *P = mmap(Addr, Size, MmapProt, MmapFlags, -1, 0);
+    if (P == MAP_FAILED) {
+      if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM)
+        dieOnMapUnmapError(errno == ENOMEM);
+      return nullptr;
+    }
+    return P;
+  }
+
+  void unmap(void *Addr, uptr Size, UNUSED uptr Flags,
+    UNUSED MapPlatformData *Data) {
+    if (munmap(Addr, static_cast<size_t>(Size)) != 0)
+      dieOnMapUnmapError();
+  }
+
+  void setMemoryPermission(uptr Addr, uptr Size, uptr Flags,
+    UNUSED MapPlatformData *Data) {
+    assert(FALSE && "Cannot alter memory permission on windows");
+#if 0
+    int Prot = (Flags & MAP_NOACCESS) ? PROT_NONE : (PROT_READ | PROT_WRITE);
+    if (mprotect(reinterpret_cast<void *>(Addr), Size, Prot) != 0)
+      dieOnMapUnmapError();
+#endif
+  }
+
+  void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size,
+    UNUSED MapPlatformData *Data) {
+    // windows seems to have no direct method to imitate the linux
+    // madvise feature. One side-effect of madvise is that the
+    // block is zero-filled. scudo relies on this when reusing a
+    // 'released' block. So just emulate that here.
+    memset(reinterpret_cast<void*>(BaseAddress+Offset), 0, Size);
+  };
+
+  namespace {
+    enum State : u32 { Unlocked = 0, Locked = 1, Sleeping = 2 };
+  }
+
+  bool HybridMutex::tryLock() {
+    return atomic_compare_exchange(&M, Unlocked, Locked) == Unlocked;
+  }
+
+  // The following is based on https://akkadia.org/drepper/futex.pdf.
+  void HybridMutex::lockSlow() {
+    u32 V = atomic_compare_exchange(&M, Unlocked, Locked);
+    if (V == Unlocked)
+      return;
+    if (V != Sleeping)
+      V = atomic_exchange(&M, Sleeping, memory_order_acquire);
+    while (V != Unlocked) {
+//      syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAIT_PRIVATE, Sleeping,
+//        nullptr, nullptr, 0);
+      u32 compare = Sleeping;
+      WaitOnAddress(&M, &compare, sizeof(compare), INFINITE);
+      V = atomic_exchange(&M, Sleeping, memory_order_acquire);
+    }
+  }
+
+  void HybridMutex::unlock() {
+    if (atomic_fetch_sub(&M, 1U, memory_order_release) != Locked) {
+      atomic_store(&M, Unlocked, memory_order_release);
+      WakeByAddressSingle(&M);
+//      syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAKE_PRIVATE, 1,
+//        nullptr, nullptr, 0);
+    }
+  }
+
+  void setAbortMessage(const char *Message) {
+  }
+
+} // namespace scudo
+
+// MSVC does not expose a 'manual' weak function scheme. It defaults to allowing
+// overriding of a function in a library with no extra notation. These are the
+// overridable weak hooks.
+
+extern "C" void __scudo_allocate_hook(void *, size_t) {};
+extern "C" void __scudo_deallocate_hook(void *ptr) {};
+extern "C" const char *__scudo_default_options() { return ""; };
+
+#pragma comment(lib, "Synchronization.lib")
+
+#endif 

compiler-rt/lib/scudo/standalone/windowsmmap.h

+/*===- WindowsMMap.h - Support library for PGO instrumentation ------------===*\
+|*
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+|* See https://llvm.org/LICENSE.txt for license information.
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+|*
+\*===----------------------------------------------------------------------===*/
+
+#ifndef PROFILE_INSTRPROFILING_WINDOWS_MMAP_H
+#define PROFILE_INSTRPROFILING_WINDOWS_MMAP_H
+
+#if defined(_WIN32)
+
+#include <basetsd.h>
+#include <io.h>
+#include <sys/types.h>
+
+/*
+ * mmap() flags
+ */
+#define PROT_READ     0x1
+#define PROT_WRITE    0x2
+#define PROT_EXEC     0x4
+#define PROT_NONE     0x0
+
+#define MAP_FILE      0x00
+#define MAP_SHARED    0x01
+#define MAP_PRIVATE   0x02
+#define MAP_ANONYMOUS 0x20
+#define MAP_ANON      MAP_ANONYMOUS
+#define MAP_FAILED    ((void *) -1)
+
+/*
+ * msync() flags
+ */
+#define MS_ASYNC        0x0001  /* return immediately */
+#define MS_INVALIDATE   0x0002  /* invalidate all cached data */
+#define MS_SYNC         0x0010  /* msync synchronously */
+
+/*
+ * flock() operations
+ */
+#define   LOCK_SH   1    /* shared lock */
+#define   LOCK_EX   2    /* exclusive lock */
+#define   LOCK_NB   4    /* don't block when locking */
+#define   LOCK_UN   8    /* unlock */
+
+#ifdef __USE_FILE_OFFSET64
+# define DWORD_HI(x) (x >> 32)
+# define DWORD_LO(x) ((x) & 0xffffffff)
+#else
+# define DWORD_HI(x) (0)
+# define DWORD_LO(x) (x)
+#endif
+
+  void *mmap(void *start, size_t length, int prot, int flags, int fd,
+    off_t offset);
+
+  int munmap(void *addr, size_t length);
+
+  int msync(void *addr, size_t length, int flags);
+
+  int flock(int fd, int operation);
+
+
+#endif /* _WIN32 */
+
+#endif /* PROFILE_INSTRPROFILING_WINDOWS_MMAP_H */

compiler-rt/lib/scudo/standalone/windowsmmap.c

+/*
+ * This code is derived from uClibc (original license follows).
+ * https://git.uclibc.org/uClibc/tree/utils/mmap-windows.c
+ */
+ /* mmap() replacement for Windows
+ *
+ * Author: Mike Frysinger <[e-mail]>
+ * Placed into the public domain
+ */
+
+/* References:
+ * CreateFileMapping: http://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx
+ * CloseHandle:       http://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx
+ * MapViewOfFile:     http://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx
+ * UnmapViewOfFile:   http://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx
+ */
+
+#if defined(_WIN32)
+
+#include "WindowsMMap.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+//#include "InstrProfiling.h"
+#define COMPILER_RT_VISIBILITY
+
+COMPILER_RT_VISIBILITY
+void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
+{
+  if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
+    return MAP_FAILED;
+  if (fd == -1) {
+    if (!(flags & MAP_ANON) || offset)
+      return MAP_FAILED;
+  } else if (flags & MAP_ANON)
+    return MAP_FAILED;
+
+  DWORD flAlloc = MEM_COMMIT;
+  DWORD flProtect;
+  if (prot & PROT_WRITE) {
+    if (prot & PROT_EXEC)
+      flProtect = PAGE_EXECUTE_READWRITE;
+    else
+      flProtect = PAGE_READWRITE;
+  }
+  else if (prot & PROT_EXEC) {
+    if (prot & PROT_READ)
+      flProtect = PAGE_EXECUTE_READ;
+    else if (prot & PROT_EXEC)
+      flProtect = PAGE_EXECUTE;
+  }
+  else if (prot & PROT_READ)
+    flProtect = PAGE_READONLY;
+  else
+  {
+    flProtect = PAGE_READONLY | PAGE_GUARD;
+    flAlloc = MEM_RESERVE;
+  }
+
+  size_t end = length + offset;
+
+  void* ret = VirtualAlloc(start, end, flAlloc, flProtect);
+
+  if (ret == NULL) {
+    int err = GetLastError();
+    return MAP_FAILED;
+  }
+  return ret;
+#if 0
+  HANDLE mmap_fd, h;
+  if (fd == -1)
+    mmap_fd = INVALID_HANDLE_VALUE;
+  else
+    mmap_fd = (HANDLE)_get_osfhandle(fd);
+  h = CreateFileMapping(mmap_fd, NULL, flProtect, DWORD_HI(end), DWORD_LO(end), NULL);
+  if (h == NULL) {
+    int err = GetLastError();
+    return MAP_FAILED;
+  }
+  
+  DWORD dwDesiredAccess;
+  if (prot & PROT_WRITE)
+    dwDesiredAccess = FILE_MAP_WRITE;
+  else
+    dwDesiredAccess = FILE_MAP_READ;
+  if (prot & PROT_EXEC)
+    dwDesiredAccess |= FILE_MAP_EXECUTE;
+  if (flags & MAP_PRIVATE)
+    dwDesiredAccess |= FILE_MAP_COPY;
+  void *ret = MapViewOfFile(h, dwDesiredAccess, DWORD_HI(offset), DWORD_LO(offset), length);
+  if (ret == NULL) {
+    CloseHandle(h);
+    ret = MAP_FAILED;
+  }
+  return ret;
+#endif
+}
+
+COMPILER_RT_VISIBILITY
+int munmap(void *addr, size_t length)
+{
+  return VirtualFree(addr, length, MEM_RELEASE);
+  //return UnmapViewOfFile(addr);
+  /* ruh-ro, we leaked handle from CreateFileMapping() ... */
+}
+
+COMPILER_RT_VISIBILITY
+int msync(void *addr, size_t length, int flags)
+{
+  if (flags & MS_INVALIDATE)
+    return -1; /* Not supported. */
+
+  /* Exactly one of MS_ASYNC or MS_SYNC must be specified. */
+  switch (flags & (MS_ASYNC | MS_SYNC)) {
+    case MS_SYNC:
+    case MS_ASYNC:
+      break;
+    default:
+      return -1;
+  }
+
+  if (!FlushViewOfFile(addr, length))
+    return -1;
+
+  if (flags & MS_SYNC) {
+    /* FIXME: No longer have access to handle from CreateFileMapping(). */
+    /*
+     * if (!FlushFileBuffers(h))
+     *   return -1;
+     */
+  }
+
+  return 0;
+}
+
+COMPILER_RT_VISIBILITY
+int lock(HANDLE handle, DWORD lockType, BOOL blocking) {
+  DWORD flags = lockType;
+  if (!blocking)
+    flags |= LOCKFILE_FAIL_IMMEDIATELY;
+
+  OVERLAPPED overlapped;
+  ZeroMemory(&overlapped, sizeof(OVERLAPPED));
+  overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  BOOL result = LockFileEx(handle, flags, 0, MAXDWORD, MAXDWORD, &overlapped);
+  if (!result) {
+    DWORD dw = GetLastError();
+
+    // In non-blocking mode, return an error if the file is locked.
+    if (!blocking && dw == ERROR_LOCK_VIOLATION)
+      return -1; // EWOULDBLOCK
+
+    // If the error is ERROR_IO_PENDING, we need to wait until the operation
+    // finishes. Otherwise, we return an error.
+    if (dw != ERROR_IO_PENDING)
+      return -1;
+
+    DWORD dwNumBytes;
+    if (!GetOverlappedResult(handle, &overlapped, &dwNumBytes, TRUE))
+      return -1;
+  }
+
+  return 0;
+}
+
+COMPILER_RT_VISIBILITY
+int flock(int fd, int operation) {
+  HANDLE handle = (HANDLE)_get_osfhandle(fd);
+  if (handle == INVALID_HANDLE_VALUE)
+    return -1;
+
+  BOOL blocking = (operation & LOCK_NB) == 0;
+  int op = operation & ~LOCK_NB;
+
+  switch (op) {
+  case LOCK_EX:
+    return lock(handle, LOCKFILE_EXCLUSIVE_LOCK, blocking);
+
+  case LOCK_SH:
+    return lock(handle, 0, blocking);
+
+  case LOCK_UN:
+    if (!UnlockFile(handle, 0, 0, MAXDWORD, MAXDWORD))
+      return -1;
+    break;
+
+  default:
+    return -1;
+  }
+
+  return 0;
+}
+
+#undef DWORD_HI
+#undef DWORD_LO
+
+#endif /* _WIN32 */

compiler-rt/lib/scudo/standalone/wrappers_c.cpp

 
 #include "allocator_config.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
+#ifdef _WIN32
+// win32 headers use this macro
+#undef INTERFACE
+#define INTERFACE
+#endif
+
 #define SCUDO_PREFIX(name) name
 #define SCUDO_ALLOCATOR Allocator
 
 extern "C" void SCUDO_PREFIX(malloc_postinit)();
 
 // Export the static allocator so that the C++ wrappers can access it.
 // Technically we could have a completely separated heap for C & C++ but in
 // reality the amount of cross pollination between the two is staggering.

compiler-rt/lib/scudo/standalone/wrappers_c.inc

 INTERFACE WEAK void SCUDO_PREFIX(malloc_enable)() { SCUDO_ALLOCATOR.enable(); }
 
 INTERFACE WEAK void SCUDO_PREFIX(malloc_disable)() {
   SCUDO_ALLOCATOR.disable();
 }
 
 void SCUDO_PREFIX(malloc_postinit)() {
   SCUDO_ALLOCATOR.initGwpAsan();
+#ifndef _WIN32
   pthread_atfork(SCUDO_PREFIX(malloc_disable), SCUDO_PREFIX(malloc_enable),
                  SCUDO_PREFIX(malloc_enable));
+#endif
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(mallopt)(int param, int value) {
   if (param == M_DECAY_TIME) {
     if (SCUDO_ANDROID) {
       if (value == 0) {
         // Will set the release values to their minimum values.
         value = INT32_MIN;
if (UNLIKELY(scudo::checkAlignedAllocAlignmentAndSize(alignment, size))) {
     }
     scudo::reportInvalidAlignedAllocAlignment(alignment, size);
   }
   return scudo::setErrnoOnNull(
       SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment));
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(malloc_info)(UNUSED int options, FILE *stream) {
+#ifndef _MSC_VER // FIXME:
   const scudo::uptr max_size =
       decltype(SCUDO_ALLOCATOR)::PrimaryT::SizeClassMap::MaxSize;
   auto *sizes = static_cast<scudo::uptr *>(
       SCUDO_PREFIX(calloc)(max_size, sizeof(scudo::uptr)));
   auto callback = [](uintptr_t, size_t size, void *arg) {
     auto *sizes = reinterpret_cast<scudo::uptr *>(arg);
     if (size < max_size)
       sizes[size]++;
   };
   SCUDO_ALLOCATOR.iterateOverChunks(0, -1ul, callback, sizes);
 
   fputs("<malloc version=\"scudo-1\">\n", stream);
   for (scudo::uptr i = 0; i != max_size; ++i)
     if (sizes[i])
       fprintf(stream, "<alloc size=\"%zu\" count=\"%zu\"/>\n", i, sizes[i]);
   fputs("</malloc>\n", stream);
   SCUDO_PREFIX(free)(sizes);
+#endif
   return 0;
 }
 
 // Disable memory tagging for the heap. The caller must disable memory tag
 // checks globally (e.g. by clearing TCF0 on aarch64) before calling this
 // function, and may not re-enable them after calling the function.
 INTERFACE WEAK void SCUDO_PREFIX(malloc_disable_memory_tagging)() {
   SCUDO_ALLOCATOR.disableMemoryTagging();

compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp

 
 // Skip this compilation unit if compiled as part of Bionic.
 #if !SCUDO_ANDROID || !_BIONIC
 
 #include "allocator_config.h"
 
 #include <stdint.h>
 
+#ifdef _WIN32
+// win32 headers use this macro
+#undef INTERFACE
+#define INTERFACE
+#endif
+
 extern "C" void malloc_postinit();
 extern HIDDEN scudo::Allocator<scudo::Config, malloc_postinit> Allocator;
 
+#ifndef _WIN32
 namespace std {
 struct nothrow_t {};
 enum class align_val_t : size_t {};
 } // namespace std
+#endif
 
 INTERFACE WEAK void *operator new(size_t size) {
   return Allocator.allocate(size, scudo::Chunk::Origin::New);
 }
 INTERFACE WEAK void *operator new[](size_t size) {
   return Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
 }
 INTERFACE WEAK void *operator new(size_t size,