[asan][test] Fix `TestCases/alloca_*` ptr-to-long cast on Windows

[alvinhochun]

Summary

64-bit Windows uses 32-bit long so these casts fail to compile with the
error "cast from pointer to smaller type". Change to instead use
uintptr_t like other tests.

[mstorsjo]

LGTM, thanks!

compiler-rt/test/asan/TestCases/alloca_big_alignment.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 //
 
 #include <assert.h>
+#include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile char str[len] __attribute__((aligned(128)));
-  assert(!(reinterpret_cast<long>(str) & 127L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 127L));
   str[index] = '1'; // BOOM
 // CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }
 
 int main(int argc, char **argv) {
   foo(10, 10);
   return 0;
 }

compiler-rt/test/asan/TestCases/alloca_detect_custom_size_.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 //
 
 #include <assert.h>
+#include <stdint.h>
 
 struct A {
   char a[3];
   int b[3];
 };
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile struct A str[len] __attribute__((aligned(32)));
-  assert(!(reinterpret_cast<long>(str) & 31L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
   str[index].a[0] = '1'; // BOOM
 // CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }
 
 int main(int argc, char **argv) {
   foo(10, 10);
   return 0;
 }

compiler-rt/test/asan/TestCases/alloca_instruments_all_paddings.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: %clangxx_asan -O3 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: %run %t 2>&1
 //
 
 #include "sanitizer/asan_interface.h"
 #include <assert.h>
+#include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile char str[len] __attribute__((aligned(32)));
-  assert(!(reinterpret_cast<long>(str) & 31L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
   char *q = (char *)__asan_region_is_poisoned((char *)str, 64);
   assert(q && ((q - str) == index));
 }
 
 int main(int argc, char **argv) {
   for (int i = 1; i < 33; ++i)
     foo(i, i);
 
   for (int i = 1; i < 33; ++i)
     foo(i, i);
 
   return 0;
 }

compiler-rt/test/asan/TestCases/alloca_overflow_partial.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 //
 
 #include <assert.h>
+#include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile char str[len] __attribute__((aligned(32)));
-  assert(!(reinterpret_cast<long>(str) & 31L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
   str[index] = '1'; // BOOM
 // CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }
 
 int main(int argc, char **argv) {
   foo(10, 10);
   return 0;
 }

compiler-rt/test/asan/TestCases/alloca_overflow_right.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 //
 
 #include <assert.h>
+#include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile char str[len] __attribute__((aligned(32)));
-  assert(!(reinterpret_cast<long>(str) & 31L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
   str[index] = '1'; // BOOM
 // CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }
 
 int main(int argc, char **argv) {
   foo(33, 10);
   return 0;
 }

compiler-rt/test/asan/TestCases/alloca_safe_access.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: %run %t 2>&1
 //
 
 #include <assert.h>
+#include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile char str[len] __attribute__((aligned(32)));
-  assert(!(reinterpret_cast<long>(str) & 31L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
   str[index] = '1';
 }
 
 int main(int argc, char **argv) {
   foo(4, 5);
   foo(39, 40);
   return 0;
 }

compiler-rt/test/asan/TestCases/alloca_underflow_left.cpp

 // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 //
 
 #include <assert.h>
+#include <stdint.h>
 
 __attribute__((noinline)) void foo(int index, int len) {
   volatile char str[len] __attribute__((aligned(32)));
-  assert(!(reinterpret_cast<long>(str) & 31L));
+  assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
   str[index] = '1'; // BOOM
 // CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }
 
 int main(int argc, char **argv) {
   foo(-1, 10);
   return 0;
 }