[sanitizers][windows] Global/LocalAlloc interception and tests

[mcgov]

Summary

GlobalAlloc and LocalAlloc are windows allocators that are frequently used in some older code bases. This adds interception and tests for those allocators with similar restrictions to the HeapAlloc and RtlHeapAllocate interceptors: moveable memory is not yet supported.

patch by Brijesh Rakholiya <[e-mail]> and Ian Kronquist <[e-mail]>

[mcgov]

clang formatted the patch

[mstorsjo]

compiler-rt/lib/asan/asan_malloc_win.cc

22

Removing <stddef.h> here breaks building with mingw, as it's necessary for the size_t type.

If I readd it here, it builds fine for me, but I presume it's removed for a reason?

FWIW, do note that this file is named .cpp in the latest git master; it looks like this diff has been made against an older tree?

Also, it's useful if the uploaded diffs are made with extra context (diff -U999)

[mcgov]

Planning to rebase this patch on master instead of release/9.x

compiler-rt/lib/asan/asan_malloc_win.cc

22

Ah yes this was against release/9.x but I will recreate it against master.

[mcgov]

rebased to master

[mstorsjo]

Builds fine in my MinGW configuration now, thanks!

compiler-rt/lib/asan/asan_malloc_win.cpp

407 ↗

(On Diff #235662)

I'm getting conflicts here when I try to apply the patch locally on master, not sure what that stems from...

[rnk]

compiler-rt/lib/asan/asan_malloc_win.cpp

57 ↗

(On Diff #235662)

I guess I prefer the spelling __declspec, since it's in the implementer's namespace.

95 ↗

(On Diff #235662)

Most of the changes in this file are from clang-format. I don't mind a few, but this is too many. Can you revert the non-functional whitespace changes far from the code you are editing? You can use git checkout -p to speed this up.

I also encourage you to run run check-sanitizer on Linux. The ASan codebase has its own linter script that doesn't run on Windows, and sometimes disagrees with clang-format.

compiler-rt/lib/interception/interception_win.cpp

524 ↗

(On Diff #235662)

So far this seems like the only functional change in this file.

compiler-rt/test/asan/TestCases/Windows/globalalloc_flags_fallback.cpp

4 ↗

(On Diff #235662)

What is the main blocker for making these tests work for 64-bit? Fixing the hotpatching interceptors?

Chromium stopped using 32-bit ASan because the address space limitations were prohibitive. I think the sanitizer-windows bot only builds x64 these days, so if we can port these, that would help make sure they are covered.

[mcgov]

compiler-rt/lib/asan/asan_malloc_win.cpp

95 ↗

(On Diff #235662)

I can do all this when I reactivate the review. I'm going to abandon this one for now and return to the Global/Local Alloc work after a few other changes are submitted.

We have a set of patches that will fix
a) the cmake issues causing both the asan and asan_dynamic libs to be built with MT.
b) Interceptor issues preventing us from supporting _DEBUG runtimes
c) remove dependence on HeapValidate for control-flow in these interceptors since it throws debug breakpoints under a debugger when the result is false (and that function also throws assertions with M[TD]d).

After some discussion with @iakronqu I'm going to pull this review for now and add these interceptors back until after these other patches are submitted.

compiler-rt/lib/asan/asan_malloc_win.cc

 #include "asan_internal.h"
 #include "asan_stack.h"
 #include "interception/interception.h"
-#include <stddef.h>
 
 // Intentionally not including windows.h here, to avoid the risk of
 // pulling in conflicting declarations of these functions. (With mingw-w64,

 typedef void *HANDLE;
 typedef const void *LPCVOID;
 typedef void *LPVOID;
+typedef HANDLE HWND;
+typedef HANDLE HGLOBAL;
+typedef HANDLE HLOCAL;
+typedef unsigned int UINT;
 
 typedef unsigned long DWORD;
 constexpr unsigned long HEAP_ZERO_MEMORY = 0x00000008;

 constexpr unsigned long HEAP_REALLOC_UNSUPPORTED_FLAGS =
     (~HEAP_ALLOCATE_SUPPORTED_FLAGS);
 
-
 extern "C" {
 LPVOID WINAPI HeapAlloc(HANDLE hHeap, DWORD dwFlags, size_t dwBytes);
 LPVOID WINAPI HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem,

 size_t WINAPI HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
 
 BOOL WINAPI HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
+HANDLE WINAPI GetProcessHeap();
+
+_declspec(dllimport) HGLOBAL WINAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes);
+_declspec(dllimport) HGLOBAL WINAPI GlobalFree(HGLOBAL hMem);
+_declspec(dllimport) HGLOBAL WINAPI GlobalSize(HGLOBAL hMem);
+_declspec(dllimport) HGLOBAL WINAPI
+    GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags);
+_declspec(dllimport) HGLOBAL WINAPI GlobalLock(HGLOBAL hMem);
+_declspec(dllimport) HGLOBAL WINAPI GlobalUnlock(HGLOBAL hMem);
+_declspec(dllimport) HLOCAL WINAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes);
+_declspec(dllimport) HLOCAL WINAPI LocalFree(HLOCAL hMem);
+_declspec(dllimport) HLOCAL WINAPI LocalSize(HLOCAL hMem);
+_declspec(dllimport) HLOCAL WINAPI
+    LocalReAlloc(HLOCAL hMem, size_t dwBytes, UINT uFlags);
+_declspec(dllimport) HLOCAL WINAPI LocalLock(HLOCAL hMem);
+_declspec(dllimport) HLOCAL WINAPI LocalUnlock(HLOCAL hMem);
 }
 
 using namespace __asan;  // NOLINT

                        Flags, BaseAddress, Size);
 }
 
+// FIXED and ZEROINIT correspond to LMEM_FIXED/GMEM_FIXED
+// and LMEM_ZEROINIT/GMEM_ZEROINIT (as provided in the documentation).
+// In case, if these values change then FIXED and ZEROINIT
+// will have to be updated accordingly.
+#define FIXED 0x0000
+#define ZEROINIT 0x0040
+
+constexpr unsigned long SHARED_ALLOC_SUPPORTED_FLAGS = (FIXED | ZEROINIT);
+constexpr unsigned long SHARED_ALLOC_UNSUPPORTED_FLAGS =
+    (~SHARED_ALLOC_SUPPORTED_FLAGS);
+
+INTERCEPTOR_WINAPI(HGLOBAL, GlobalAlloc, UINT uFlags, SIZE_T dwBytes) {
+  // If we encounter an unsupported flag, then we fall
+  // back to the original allocator.
+  if (uFlags & SHARED_ALLOC_UNSUPPORTED_FLAGS) {
+    return REAL(GlobalAlloc)(uFlags, dwBytes);
+  }
+
+  GET_STACK_TRACE_MALLOC;
+  if (uFlags & ZEROINIT)
+    return asan_calloc(dwBytes, 1, &stack);
+  else
+    return asan_malloc(dwBytes, &stack);
+}
+
+INTERCEPTOR_WINAPI(HGLOBAL, GlobalFree, HGLOBAL hMem) {
+  // If the memory we are trying to free is not owned
+  // by ASan heap, then fall back to the original GlobalFree.
+  if (OWNED_BY_RTL(GetProcessHeap(), hMem)) {
+    return REAL(GlobalFree)(hMem);
+  }
+  GET_STACK_TRACE_FREE;
+  asan_free(hMem, &stack, FROM_MALLOC);
+  return nullptr;
+}
+
+INTERCEPTOR_WINAPI(SIZE_T, GlobalSize, HGLOBAL hMem) {
+  // We need to check whether the ASAN allocator owns the pointer
+  // we're about to use. Allocations might occur before interception
+  // takes place, so if it is not owned by RTL heap, the we can
+  // pass it to ASAN heap for inspection.
+  if (!asan_inited || OWNED_BY_RTL(GetProcessHeap(), hMem))
+    return REAL(GlobalSize)(hMem);
+
+  GET_CURRENT_PC_BP_SP;
+  (void)sp;
+  return asan_malloc_usable_size(hMem, pc, bp);
+}
+
+namespace __asan {
+using GlobalLocalAlloc = HANDLE(WINAPI *)(UINT, SIZE_T);
+using GlobalLocalRealloc = HANDLE(WINAPI *)(HANDLE, SIZE_T, UINT);
+using GlobalLocalSize = SIZE_T(WINAPI *)(HANDLE);
+using GlobalLocalFree = HANDLE(WINAPI *)(HANDLE);
+using GlobalLocalLock = LPVOID(WINAPI *)(HANDLE);
+using GlobalLocalUnlock = LPVOID(WINAPI *)(HANDLE);
+
+enum class AllocationOwnership {
+  OWNED_BY_UNKNOWN,
+  OWNED_BY_ASAN,
+  OWNED_BY_RTL,
+  OWNED_BY_GLOBAL_OR_LOCAL,
+  OWNED_BY_GLOBAL_OR_LOCAL_HANDLE,
+};
+
+void *RtlToAsan(void *mPtr, size_t old_size, size_t dwBytes,
+                GlobalLocalFree freeFunc, BufferedStackTrace *stack) {
+  // Transfer from RTL owned allocation to ASAN owned allocation
+  void *replacement_alloc;
+  replacement_alloc = asan_calloc(dwBytes, 1, stack);
+  if (replacement_alloc) {
+    if (old_size == ((SIZE_T)0) - 1) {
+      asan_free(replacement_alloc, stack, FROM_MALLOC);
+      return nullptr;
+    }
+    REAL(memcpy)(replacement_alloc, mPtr, old_size);
+    freeFunc((HANDLE)mPtr);
+  }
+  return replacement_alloc;
+}
+
+void *AsanToRtl(void *mPtr, UINT uFlags, SIZE_T dwBytes,
+                GlobalLocalAlloc allocFunc, GlobalLocalLock lockFunc,
+                GlobalLocalLock unlockFunc, BufferedStackTrace *stack, uptr pc,
+                uptr bp) {
+  // Transfer from ASAN owned allocation to RTL owned allocation
+  void *replacement_alloc;
+  HANDLE mem = allocFunc(uFlags, dwBytes);
+  // GlobalLock/LocalLock return a pointer to the memory owned by the mem
+  // handle. We need the pointer to copy the data over from the ASAN owned
+  // memory.
+  replacement_alloc = (void *)lockFunc(mem);
+  size_t old_usable_size = 0;
+  if (replacement_alloc) {
+    old_usable_size = asan_malloc_usable_size(mPtr, pc, bp);
+    REAL(memcpy)(replacement_alloc, mPtr, Min<size_t>(dwBytes, old_usable_size));
+    asan_free(mPtr, stack, FROM_MALLOC);
+  }
+  unlockFunc(mem);
+  return replacement_alloc;
+}
+
+void *ReAllocToAsan(UINT uFlags, void *mPtr, size_t dwBytes, uptr pc, uptr bp,
+                    BufferedStackTrace *stack) {
+  // GlobalAlloc, LocalAlloc, GlocalReAlloc and LocalReAlloc all
+  // accept 0 sized allocations. Passing a zero size into asan_realloc will
+  // free the allocation. To avoid this and keep behavior consistent, fudge
+  // the size if zero (asan_malloc already does this).
+  if (dwBytes == 0)
+    dwBytes = 1;
+
+  size_t old_size;
+  if (uFlags & ZEROINIT)
+    old_size = asan_malloc_usable_size(mPtr, pc, bp);
+
+  void *ptr = asan_realloc(mPtr, dwBytes, stack);
+  if (ptr == nullptr)
+    return nullptr;
+
+  if (uFlags & ZEROINIT) {
+    size_t new_size = asan_malloc_usable_size(ptr, pc, bp);
+    if (old_size < new_size)
+      REAL(memset)(((u8 *)ptr) + old_size, 0, new_size - old_size);
+  }
+  return ptr;
+}
+
+AllocationOwnership CheckGlobalLocalHeapOwnership(
+    HANDLE hMem, GlobalLocalLock lockFunc, GlobalLocalUnlock unlockFunc) {
+  /*  To figure the validity of hMem, we use GlobalLock/LocalLock. Those two
+   * functions can return three things: (1) the pointer that's passed in, in
+   * which case it is a pointer owned by the Global/Local heap (2) the pointer
+   * to the allocated object if it's a Global/Local heap HANDLE (3) nullptr if it's
+   * a pointer which does not belong to the Global/Local heap Using these three
+   * return types, we figure out if the pointer is TYPE_VALID_PTR or TYPE_HANDLE
+   * or TYPE_UNKNOWN_PTR
+   *
+   * NOTE: As an implementation detail, movable memory objects also live on the
+   * heap. HeapValidate will return true if given a moveable memory handle.
+   *
+   */
+
+  // Do this first to avoid expensive checks if the pointer is owned by ASAN.
+  if (__sanitizer_get_ownership(hMem)) {
+    return AllocationOwnership::OWNED_BY_ASAN;
+  }
+
+  // It is not safe to pass wild pointers to GlobalLock/LocalLock.
+  if (HeapValidate(GetProcessHeap(), 0, hMem)) {
+    void *ptr = lockFunc(hMem);
+    // We don't care whether ptr is moved after this point as we're just trying
+    // to determine where it came from.
+    unlockFunc(hMem);
+    if (ptr == hMem) {
+      return AllocationOwnership::OWNED_BY_GLOBAL_OR_LOCAL;
+    } else if (ptr != nullptr) {
+      return AllocationOwnership::OWNED_BY_GLOBAL_OR_LOCAL_HANDLE;
+    }
+  }
+  return AllocationOwnership::OWNED_BY_UNKNOWN;
+}
+
+void *ReAllocGlobalLocal(GlobalLocalRealloc reallocFunc,
+                         GlobalLocalSize sizeFunc, GlobalLocalFree freeFunc,
+                         GlobalLocalAlloc allocFunc, GlobalLocalLock lockFunc,
+                         GlobalLocalUnlock unlockFunc, HANDLE hMem,
+                         DWORD dwBytes, UINT uFlags) {
+  CHECK(reallocFunc && sizeFunc && freeFunc && allocFunc);
+  GET_STACK_TRACE_MALLOC;
+  GET_CURRENT_PC_BP_SP;
+  (void)sp;
+
+  bool only_asan_supported_flags =
+      (SHARED_ALLOC_UNSUPPORTED_FLAGS & uFlags) == 0;
+
+  AllocationOwnership ownershipState =
+      CheckGlobalLocalHeapOwnership(hMem, lockFunc, unlockFunc);
+
+  // If this global block which was allocated before the ASAN
+  // runtime came up OR if mPtr is invalid, use the real GlobalReAlloc function.
+  if (UNLIKELY(!asan_inited) ||
+      ownershipState == AllocationOwnership::OWNED_BY_GLOBAL_OR_LOCAL_HANDLE) {
+    return reallocFunc(hMem, dwBytes, uFlags);
+  }
+
+  // Since hMem is not a handle to moveable memory we may safely cast it to
+  // pointer.
+  void *mPtr = (void *)hMem;
+
+  if (ownershipState == AllocationOwnership::OWNED_BY_GLOBAL_OR_LOCAL ||
+      (ownershipState == AllocationOwnership::OWNED_BY_UNKNOWN &&
+       !only_asan_supported_flags)) {
+    if (only_asan_supported_flags) {
+      // if this is a conversion to ASAN supported flags, transfer this
+      // allocation to the ASAN allocator
+      return RtlToAsan(mPtr, sizeFunc(mPtr), dwBytes, freeFunc, &stack);
+    } else {
+      // owned by this heap or neither with unsupported ASAN flags,
+      // just pass back to original allocator
+      CHECK(ownershipState == AllocationOwnership::OWNED_BY_GLOBAL_OR_LOCAL ||
+            ownershipState == AllocationOwnership::OWNED_BY_UNKNOWN);
+      CHECK(!only_asan_supported_flags);
+      return reallocFunc(mPtr, dwBytes, uFlags);
+    }
+  }
+
+  if (ownershipState == AllocationOwnership::OWNED_BY_ASAN &&
+      !only_asan_supported_flags) {
+    // Conversion to unsupported flags allocation,
+    // transfer this allocation back to the original allocator.
+    return AsanToRtl(mPtr, uFlags, dwBytes, allocFunc, lockFunc, unlockFunc,
+                     &stack, pc, bp);
+  }
+
+  CHECK((ownershipState == AllocationOwnership::OWNED_BY_ASAN ||
+         ownershipState == AllocationOwnership::OWNED_BY_RTL ||
+         ownershipState == AllocationOwnership::OWNED_BY_UNKNOWN) &&
+        only_asan_supported_flags);
+
+  return ReAllocToAsan(uFlags, mPtr, dwBytes, pc, bp, &stack);
+}
+}  // namespace __asan
+
+INTERCEPTOR_WINAPI(HGLOBAL, GlobalReAlloc, HGLOBAL hMem, DWORD dwBytes,
+                   UINT uFlags) {
+  return ReAllocGlobalLocal(
+      (GlobalLocalRealloc)REAL(GlobalReAlloc),
+      (GlobalLocalSize)REAL(GlobalSize), (GlobalLocalFree)REAL(GlobalFree),
+      (GlobalLocalAlloc)REAL(GlobalAlloc), (GlobalLocalLock)GlobalLock,
+      (GlobalLocalUnlock)GlobalUnlock, (HANDLE)hMem, dwBytes, uFlags);
+}
+
+INTERCEPTOR_WINAPI(HLOCAL, LocalAlloc, UINT uFlags, SIZE_T uBytes) {
+  // If we encounter an unsupported flag, then we fall
+  // back to the original allocator.
+  if (uFlags & SHARED_ALLOC_UNSUPPORTED_FLAGS) {
+    return REAL(LocalAlloc)(uFlags, uBytes);
+  }
+
+  GET_STACK_TRACE_MALLOC;
+  if (uFlags & ZEROINIT)
+    return asan_calloc(uBytes, 1, &stack);
+  else
+    return asan_malloc(uBytes, &stack);
+}
+
+INTERCEPTOR_WINAPI(HLOCAL, LocalFree, HGLOBAL hMem) {
+  // If the memory we are trying to free is not owned
+  // ASan heap, then fall back to the original LocalFree.
+  if (OWNED_BY_RTL(GetProcessHeap(), hMem)) {
+    return REAL(LocalFree)(hMem);
+  }
+
+  GET_STACK_TRACE_FREE;
+  asan_free(hMem, &stack, FROM_MALLOC);
+  return nullptr;
+}
+
+INTERCEPTOR_WINAPI(SIZE_T, LocalSize, HGLOBAL hMem) {
+  // We need to check whether the ASAN allocator owns the pointer
+  // we're about to use. Allocations might occur before interception
+  // takes place, so if it is not owned by RTL heap, the we can
+  // pass it to ASAN heap for inspection.
+  if (!asan_inited || OWNED_BY_RTL(GetProcessHeap(), hMem))
+    return REAL(LocalSize)(hMem);
+
+  GET_CURRENT_PC_BP_SP;
+  (void)sp;
+  return asan_malloc_usable_size(hMem, pc, bp);
+}
+
+INTERCEPTOR_WINAPI(HLOCAL, LocalReAlloc, HGLOBAL hMem, DWORD dwBytes,
+                   UINT uFlags) {
+  return ReAllocGlobalLocal(
+      (GlobalLocalRealloc)REAL(LocalReAlloc), (GlobalLocalSize)REAL(LocalSize),
+      (GlobalLocalFree)REAL(LocalFree), (GlobalLocalAlloc)REAL(LocalAlloc),
+      (GlobalLocalLock)LocalLock, (GlobalLocalUnlock)LocalUnlock, (HANDLE)hMem,
+      dwBytes, uFlags);
+}
+
 namespace __asan {
 
 static void TryToOverrideFunction(const char *fname, uptr new_func) {

   TryToOverrideFunction("_expand_base", (uptr)_expand);
 
   if (flags()->windows_hook_rtl_allocators) {
+    INTERCEPT_FUNCTION(GlobalAlloc);
+    INTERCEPT_FUNCTION(GlobalFree);
+    INTERCEPT_FUNCTION(GlobalSize);
+    INTERCEPT_FUNCTION(GlobalReAlloc);
+    INTERCEPT_FUNCTION(LocalAlloc);
+    INTERCEPT_FUNCTION(LocalFree);
+    INTERCEPT_FUNCTION(LocalSize);
+    INTERCEPT_FUNCTION(LocalReAlloc);
     INTERCEPT_FUNCTION(HeapSize);
     INTERCEPT_FUNCTION(HeapFree);
     INTERCEPT_FUNCTION(HeapReAlloc);

compiler-rt/lib/interception/interception_win.cc

     case 0xec8348:    // 48 83 ec XX : sub rsp, XX
     case 0xf88349:    // 49 83 f8 XX : cmp r8, XX
     case 0x588948:    // 48 89 58 XX : mov QWORD PTR[rax + XX], rbx
+    case 0x245489:    // 89 54 24 XX : mov DWORD PTR[rsp + XX], edx
       return 4;
 
     case 0xec8148:    // 48 81 EC XX XX XX XX : sub rsp, XXXXXXXX

       "msvcr120.dll",      // VS2013
       "vcruntime140.dll",  // VS2015
       "ucrtbase.dll",      // Universal CRT
+      "KERNELBASE.dll",    // KernelBase for GlobalAlloc and LocalAlloc (dynamic)
       // NTDLL should go last as it exports some functions that we should
       // override in the CRT [presumably only used internally].
       "ntdll.dll", NULL};

compiler-rt/test/asan/TestCases/Windows/dll_host.cc

 // IMPORT: __asan_wrap_HeapFree
 // IMPORT: __asan_wrap_HeapReAlloc
 // IMPORT: __asan_wrap_HeapSize
+// IMPORT: __asan_wrap_GlobalAlloc
+// IMPORT: __asan_wrap_GlobalFree
+// IMPORT: __asan_wrap_GlobalReAlloc
+// IMPORT: __asan_wrap_GlobalSize
+// IMPORT: __asan_wrap_LocalAlloc
+// IMPORT: __asan_wrap_LocalFree
+// IMPORT: __asan_wrap_LocalReAlloc
+// IMPORT: __asan_wrap_LocalSize
 // IMPORT: __asan_wrap_CreateThread
 // IMPORT: __asan_wrap_RaiseException
 // IMPORT: __asan_wrap_RtlRaiseException

compiler-rt/test/asan/TestCases/Windows/globalalloc.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer;
+  buffer = (char*)GlobalAlloc(GMEM_FIXED, 32),
+  buffer[33] = 'a';
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}

compiler-rt/test/asan/TestCases/Windows/globalalloc_doublefree.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+
+
+#include <windows.h>
+#include <cassert>
+
+int main(){
+    void* allocation = GlobalAlloc(GMEM_FIXED, 10);
+    assert(allocation != 0);
+    assert( GlobalFree(allocation) == NULL );
+    GlobalFree(allocation); //will dump
+    assert(0 && "GlobalFree double free should produce an ASAN dump\n" );
+    return 0;
+}
+
+// CHECK: AddressSanitizer: attempting double-free on [[addr:0x[0-9a-fA-F]+]] in thread T0:
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/globalalloc_flags_fallback.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+#include <assert.h>
+#include <stdio.h>
+#include <windows.h>
+
+extern "C" int
+__sanitizer_get_ownership(const volatile void *p);
+
+int main() {
+  char *buffer;
+  HGLOBAL hMem;
+  hMem = GlobalAlloc(GMEM_MOVEABLE, 32);
+  buffer = (char*) GlobalLock(hMem);
+  buffer[0] = 'a';
+  assert(!__sanitizer_get_ownership(buffer));
+  GlobalUnlock(hMem);
+  GlobalFree(buffer);
+  puts("Okay");
+  // CHECK: Okay
+}

compiler-rt/test/asan/TestCases/Windows/globalalloc_huge.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=allocator_may_return_null=true %run %t
+// RUN: %env_asan_opts=allocator_may_return_null=true:windows_hook_rtl_allocators=true %run %t
+// UNSUPPORTED: asan-64-bits
+#include <stdio.h>
+#include <windows.h>
+int main() {
+  void *nope = GlobalAlloc(GMEM_FIXED, ((size_t)0) - 1);
+  if (nope != nullptr) {
+    puts("Fail");
+    return 1;
+  }
+  puts("Pass");
+  return 0;
+}
+// CHECK: Pass
+// CHECK-NOT: Fail 
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/globalalloc_sanity.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+#include <windows.h>
+
+int main() {
+  char *buffer;
+  buffer = (char*)GlobalAlloc(GMEM_FIXED, 32),
+  buffer[0] = 'a';
+  GlobalFree(buffer);
+  puts("Okay");
+// CHECK: Okay
+}

compiler-rt/test/asan/TestCases/Windows/globalalloc_transfer.cc

+#include "sanitizer\allocator_interface.h"
+#include <cassert>
+#include <stdio.h>
+#include <windows.h>
+// RUN: %clang_cl_asan %s -o%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+
+int main() {
+  void *buffer, *realloc;
+  HGLOBAL hMem1, hMem2, hMem3;
+  
+  //owned by rtl
+  hMem1 = GlobalAlloc(GMEM_MOVEABLE, 100);
+  buffer = (void *) GlobalLock(hMem1);
+  assert(buffer);
+
+  // still owned by rtl
+  hMem2 = GlobalReAlloc(buffer, 100, GMEM_MOVEABLE);
+  GlobalUnlock(hMem1);
+  buffer = (void *) GlobalLock(hMem2);
+  assert(buffer);
+  assert(!__sanitizer_get_ownership(buffer));
+  assert(HeapValidate(GetProcessHeap(), 0, buffer));
+  
+  //convert to asan owned
+  realloc = GlobalReAlloc(buffer, 500, GMEM_FIXED);
+  GlobalUnlock(hMem2);
+  buffer = nullptr;
+  assert(realloc);
+  assert(__sanitizer_get_ownership(realloc));
+  
+  //convert back to rtl owned;
+  hMem3 = GlobalReAlloc(realloc, 100, GMEM_MOVEABLE);
+  buffer = (void*) GlobalLock(hMem3);
+  assert(buffer);
+  assert(!__sanitizer_get_ownership(buffer));
+  assert(HeapValidate(GetProcessHeap(), 0, buffer));
+  
+  GlobalUnlock(hMem3);
+  printf("Success\n");
+}
+
+// CHECK-NOT: assert
+// CHECK-NOT: AddressSanitizer
+// CHECK: Success
+

compiler-rt/test/asan/TestCases/Windows/globalalloc_uaf.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer;
+  buffer = (char*)GlobalAlloc(GMEM_FIXED, 32),
+  GlobalFree(buffer);
+  buffer[0] = 'a';
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}

compiler-rt/test/asan/TestCases/Windows/globalalloc_zero_size.cc

+// RUN: %clang_cl_asan /Od -o %t %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s
+// RUN: %clang_cl /Od -o %t %s
+// RUN: %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+#include <cassert>
+#include <stdio.h>
+#include <windows.h>
+#include <winbase.h>
+
+int main() {
+  void *ptr = GlobalAlloc(GMEM_FIXED, 4);
+  assert(ptr);
+  void *ptr2 = GlobalReAlloc(ptr, 0, GMEM_ZEROINIT);
+  assert(ptr2);
+  GlobalFree(ptr2);
+  fprintf(stderr, "passed!\n");
+}
+
+// CHECK-NOT: double-free
+// CHECK-NOT: AddressSanitizer
+// CHECK: passed!
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/globalrealloc.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+#include <stdio.h>
+#include <windows.h>
+#include <winbase.h>
+
+int main() {
+  char *oldbuf;
+  size_t sz = 8;
+  oldbuf = (char *)GlobalAlloc(GMEM_FIXED, sz);
+  char *newbuf = oldbuf;
+  while (oldbuf == newbuf) {
+    sz *= 2;
+    newbuf = (char *)GlobalReAlloc(oldbuf, sz, GMEM_ZEROINIT);
+  }
+
+  newbuf[0] = 'a';
+  oldbuf[0] = 'a';
+  // CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+  // CHECK: WRITE of size 1 at [[WRITE2:0x[0-9a-f]+]] thread T0
+  // CHECK: #0 {{0x[0-9a-f]+ in main.*}}:[[@LINE-3]]
+}
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/heapalloc_freenull.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1
+// UNSUPPORTED: asan-64-bits
+#include <cassert>
+#include <windows.h>
+
+int main() {
+  void *allocation = HeapAlloc(GetProcessHeap(), 0, 10);
+  assert(allocation != 0);
+  HeapFree(GetProcessHeap(), 0, (void *)0);
+//TODO: This should actually trigger a report, since Free(NULL) is undefined for windows.
+  return 0;
+}

compiler-rt/test/asan/TestCases/Windows/heapalloc_huge.cc

 // RUN: %env_asan_opts=allocator_may_return_null=true %run %t
 // RUN: %env_asan_opts=allocator_may_return_null=true:windows_hook_rtl_allocators=true %run %t
 // UNSUPPORTED: asan-64-bits
+#include <stdio.h>
 #include <windows.h>
 int main() {
   void *nope = HeapAlloc(GetProcessHeap(), 0, ((size_t)0) - 1);

compiler-rt/test/asan/TestCases/Windows/localalloc.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer;
+  buffer = (char*)LocalAlloc(LMEM_FIXED, 32),
+  buffer[33] = 'a';
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}

compiler-rt/test/asan/TestCases/Windows/localalloc_doublefree.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+
+
+#include <windows.h>
+#include <cassert>
+
+int main(){
+    void* allocation = LocalAlloc(LMEM_FIXED, 10);
+    assert(allocation != 0);
+    assert(LocalFree(allocation) == NULL);
+    LocalFree(allocation); //will dump
+    assert(0 && "LocalFree double free should produce an ASAN dump\n" );
+    return 0;
+}
+
+// CHECK: AddressSanitizer: attempting double-free on [[addr:0x[0-9a-fA-F]+]] in thread T0:
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/localalloc_flags_fallback.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+#include <assert.h>
+#include <stdio.h>
+#include <windows.h>
+
+extern "C" int
+__sanitizer_get_ownership(const volatile void *p);
+
+int main() {
+  char *buffer;
+  HGLOBAL hMem;
+  hMem = LocalAlloc(LMEM_MOVEABLE, 32);
+  buffer = (char*) LocalLock(hMem);
+  buffer[0] = 'a';
+  assert(!__sanitizer_get_ownership(buffer));
+  LocalUnlock(hMem);
+  LocalFree(buffer);
+  puts("Okay");
+  // CHECK: Okay
+}
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/localalloc_huge.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=allocator_may_return_null=true %run %t
+// RUN: %env_asan_opts=allocator_may_return_null=true:windows_hook_rtl_allocators=true %run %t
+// UNSUPPORTED: asan-64-bits
+#include <windows.h>
+int main() {
+  void *nope = LocalAlloc(LMEM_FIXED, ((size_t)0) - 1);
+  return nope != nullptr;
+}
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/localalloc_sanity.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+#include <windows.h>
+
+int main() {
+  char *buffer;
+  buffer = (char*)LocalAlloc(LMEM_FIXED, 32),
+  buffer[0] = 'a';
+  LocalFree(buffer);
+  puts("Okay");
+// CHECK: Okay
+}

compiler-rt/test/asan/TestCases/Windows/localalloc_uaf.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer;
+  buffer = (char*)LocalAlloc(LMEM_FIXED, 32),
+  LocalFree(buffer);
+  buffer[0] = 'a';
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}

compiler-rt/test/asan/TestCases/Windows/localalloc_zero_size.cc

+// RUN: %clang_cl_asan /Od -o %t %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s
+// RUN: %clang_cl /Od -o %t %s
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+#include <cassert>
+#include <stdio.h>
+#include <windows.h>
+#include <winbase.h>
+
+int main() {
+  void *ptr = LocalAlloc(LMEM_FIXED, 4);
+  assert(ptr);
+  void *ptr2 = LocalReAlloc(ptr, 0, LMEM_ZEROINIT);
+  assert(ptr2);
+  LocalFree(ptr2);
+  fprintf(stderr, "passed!\n");
+
+}
+
+// CHECK-NOT: double-free
+// CHECK-NOT: AddressSanitizer
+// CHECK: passed!
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/localrealloc.cc

+// RUN: %clang_cl_asan /Od %s -Fe%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+#include <stdio.h>
+#include <windows.h>
+#include <winbase.h>
+
+int main() {
+  char *oldbuf;
+  size_t sz = 8;
+  oldbuf = (char *)LocalAlloc(LMEM_FIXED, sz);
+  char *newbuf = oldbuf;
+  while (oldbuf == newbuf) {
+    sz *= 2;
+    newbuf = (char *)LocalReAlloc(oldbuf, sz, LMEM_ZEROINIT);
+  }
+
+  newbuf[0] = 'a';
+  oldbuf[0] = 'a';
+  // CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+  // CHECK: WRITE of size 1 at [[WRITE2:0x[0-9a-f]+]] thread T0
+  // CHECK: #0 {{0x[0-9a-f]+ in main.*}}:[[@LINE-3]]
+}
 No newline at end of file

compiler-rt/test/asan/TestCases/Windows/localrealloc_transfer.cc

+#include "sanitizer\allocator_interface.h"
+#include <cassert>
+#include <stdio.h>
+#include <windows.h>
+// RUN: %clang_cl_asan %s -o%t
+// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: asan-64-bits
+
+int main() {
+  void *buffer, *realloc;
+  HLOCAL hMem1, hMem2, hMem3;
+  
+  //owned by rtl
+  hMem1 = LocalAlloc(LMEM_MOVEABLE, 100);
+  buffer = (void *) LocalLock(hMem1);
+  assert(buffer);
+
+  // still owned by rtl
+  hMem2 = LocalReAlloc(buffer, 100, LMEM_MOVEABLE);
+  LocalUnlock(hMem1);
+  buffer = (void *) LocalLock(hMem2);
+  assert(buffer);
+  assert(!__sanitizer_get_ownership(buffer));
+  assert(HeapValidate(GetProcessHeap(), 0, buffer));
+  
+  //convert to asan owned
+  realloc = LocalReAlloc(buffer, 500, LMEM_FIXED);
+  LocalUnlock(hMem2);
+  buffer = nullptr;
+  assert(realloc);
+  assert(__sanitizer_get_ownership(realloc));
+  
+  //convert back to rtl owned;
+  hMem3 = LocalReAlloc(realloc, 100, LMEM_MOVEABLE);
+  buffer = (void*) LocalLock(hMem3);
+  assert(buffer);
+  assert(!__sanitizer_get_ownership(buffer));
+  assert(HeapValidate(GetProcessHeap(), 0, buffer));
+  
+  LocalUnlock(hMem3);
+  printf("Success\n");
+}
+
+// CHECK-NOT: assert
+// CHECK-NOT: AddressSanitizer
+// CHECK: Success
+