[asan] more renaming

llvm-svn: 157746

29 files changed, 650 insertions, 651 deletions

diff --git a/compiler-rt/lib/asan/asan_allocator.cc b/compiler-rt/lib/asan/asan_allocator.cc
index 64288120dfb..900384febae 100644
--- a/compiler-rt/lib/asan/asan_allocator.cc
+++ b/compiler-rt/lib/asan/asan_allocator.cc
@@ -42,27 +42,27 @@
 namespace __asan {
 
 #define  REDZONE FLAG_redzone
-static const size_t kMinAllocSize = REDZONE * 2;
+static const uptr kMinAllocSize = REDZONE * 2;
 static const uint64_t kMaxAvailableRam = 128ULL << 30;  // 128G
-static const size_t kMaxThreadLocalQuarantine = 1 << 20;  // 1M
+static const uptr kMaxThreadLocalQuarantine = 1 << 20;  // 1M
 
-static const size_t kMinMmapSize = (ASAN_LOW_MEMORY) ? 4UL << 17 : 4UL << 20;
-static const size_t kMaxSizeForThreadLocalFreeList =
+static const uptr kMinMmapSize = (ASAN_LOW_MEMORY) ? 4UL << 17 : 4UL << 20;
+static const uptr kMaxSizeForThreadLocalFreeList =
     (ASAN_LOW_MEMORY) ? 1 << 15 : 1 << 17;
 
 // Size classes less than kMallocSizeClassStep are powers of two.
 // All other size classes are multiples of kMallocSizeClassStep.
-static const size_t kMallocSizeClassStepLog = 26;
-static const size_t kMallocSizeClassStep = 1UL << kMallocSizeClassStepLog;
+static const uptr kMallocSizeClassStepLog = 26;
+static const uptr kMallocSizeClassStep = 1UL << kMallocSizeClassStepLog;
 
 static const uptr kMaxAllowedMallocSize =
     (__WORDSIZE == 32) ? 3UL << 30 : 8UL << 30;
 
-static inline bool IsAligned(uintptr_t a, uintptr_t alignment) {
+static inline bool IsAligned(uptr a, uptr alignment) {
   return (a & (alignment - 1)) == 0;
 }
 
-static inline size_t Log2(size_t x) {
+static inline uptr Log2(uptr x) {
   CHECK(IsPowerOfTwo(x));
 #if !defined(_WIN32) || defined(__clang__)
   return __builtin_ctzl(x);
@@ -77,7 +77,7 @@ static inline size_t Log2(size_t x) {
 #endif
 }
 
-static inline size_t RoundUpToPowerOfTwo(size_t size) {
+static inline uptr RoundUpToPowerOfTwo(uptr size) {
   CHECK(size);
   if (IsPowerOfTwo(size)) return size;
 
@@ -94,7 +94,7 @@ static inline size_t RoundUpToPowerOfTwo(size_t size) {
   return 1UL << (up + 1);
 }
 
-static inline size_t SizeClassToSize(uint8_t size_class) {
+static inline uptr SizeClassToSize(uint8_t size_class) {
   CHECK(size_class < kNumberOfSizeClasses);
   if (size_class <= kMallocSizeClassStepLog) {
     return 1UL << size_class;
@@ -103,10 +103,10 @@ static inline size_t SizeClassToSize(uint8_t size_class) {
   }
 }
 
-static inline uint8_t SizeToSizeClass(size_t size) {
+static inline uint8_t SizeToSizeClass(uptr size) {
   uint8_t res = 0;
   if (size <= kMallocSizeClassStep) {
-    size_t rounded = RoundUpToPowerOfTwo(size);
+    uptr rounded = RoundUpToPowerOfTwo(size);
     res = Log2(rounded);
   } else {
     res = ((size + kMallocSizeClassStep - 1) / kMallocSizeClassStep)
@@ -119,7 +119,7 @@ static inline uint8_t SizeToSizeClass(size_t size) {
 
 // Given REDZONE bytes, we need to mark first size bytes
 // as addressable and the rest REDZONE-size bytes as unaddressable.
-static void PoisonHeapPartialRightRedzone(uintptr_t mem, size_t size) {
+static void PoisonHeapPartialRightRedzone(uptr mem, uptr size) {
   CHECK(size <= REDZONE);
   CHECK(IsAligned(mem, REDZONE));
   CHECK(IsPowerOfTwo(SHADOW_GRANULARITY));
@@ -129,10 +129,10 @@ static void PoisonHeapPartialRightRedzone(uintptr_t mem, size_t size) {
                                   kAsanHeapRightRedzoneMagic);
 }
 
-static uint8_t *MmapNewPagesAndPoisonShadow(size_t size) {
+static uint8_t *MmapNewPagesAndPoisonShadow(uptr size) {
   CHECK(IsAligned(size, kPageSize));
   uint8_t *res = (uint8_t*)AsanMmapSomewhereOrDie(size, __FUNCTION__);
-  PoisonShadow((uintptr_t)res, size, kAsanHeapLeftRedzoneMagic);
+  PoisonShadow((uptr)res, size, kAsanHeapLeftRedzoneMagic);
   if (FLAG_debug) {
     Printf("ASAN_MMAP: [%p, %p)\n", res, res + size);
   }
@@ -162,33 +162,33 @@ struct ChunkBase {
   uint32_t   offset;  // User-visible memory starts at this+offset (beg()).
   int32_t    alloc_tid;
   int32_t    free_tid;
-  size_t     used_size;  // Size requested by the user.
+  uptr     used_size;  // Size requested by the user.
   AsanChunk *next;
 
-  uintptr_t   beg() { return (uintptr_t)this + offset; }
-  size_t Size() { return SizeClassToSize(size_class); }
+  uptr   beg() { return (uptr)this + offset; }
+  uptr Size() { return SizeClassToSize(size_class); }
   uint8_t SizeClass() { return size_class; }
 };
 
 struct AsanChunk: public ChunkBase {
   uint32_t *compressed_alloc_stack() {
     CHECK(REDZONE >= sizeof(ChunkBase));
-    return (uint32_t*)((uintptr_t)this + sizeof(ChunkBase));
+    return (uint32_t*)((uptr)this + sizeof(ChunkBase));
   }
   uint32_t *compressed_free_stack() {
     CHECK(REDZONE >= sizeof(ChunkBase));
-    return (uint32_t*)((uintptr_t)this + REDZONE);
+    return (uint32_t*)((uptr)this + REDZONE);
   }
 
   // The left redzone after the ChunkBase is given to the alloc stack trace.
-  size_t compressed_alloc_stack_size() {
+  uptr compressed_alloc_stack_size() {
     return (REDZONE - sizeof(ChunkBase)) / sizeof(uint32_t);
   }
-  size_t compressed_free_stack_size() {
+  uptr compressed_free_stack_size() {
     return (REDZONE) / sizeof(uint32_t);
   }
 
-  bool AddrIsInside(uintptr_t addr, size_t access_size, size_t *offset) {
+  bool AddrIsInside(uptr addr, uptr access_size, uptr *offset) {
     if (addr >= beg() && (addr + access_size) <= (beg() + used_size)) {
       *offset = addr - beg();
       return true;
@@ -196,7 +196,7 @@ struct AsanChunk: public ChunkBase {
     return false;
   }
 
-  bool AddrIsAtLeft(uintptr_t addr, size_t access_size, size_t *offset) {
+  bool AddrIsAtLeft(uptr addr, uptr access_size, uptr *offset) {
     if (addr < beg()) {
       *offset = beg() - addr;
       return true;
@@ -204,7 +204,7 @@ struct AsanChunk: public ChunkBase {
     return false;
   }
 
-  bool AddrIsAtRight(uintptr_t addr, size_t access_size, size_t *offset) {
+  bool AddrIsAtRight(uptr addr, uptr access_size, uptr *offset) {
     if (addr + access_size >= beg() + used_size) {
       if (addr <= beg() + used_size)
         *offset = 0;
@@ -215,8 +215,8 @@ struct AsanChunk: public ChunkBase {
     return false;
   }
 
-  void DescribeAddress(uintptr_t addr, size_t access_size) {
-    size_t offset;
+  void DescribeAddress(uptr addr, uptr access_size) {
+    uptr offset;
     Printf("%p is located ", addr);
     if (AddrIsInside(addr, access_size, &offset)) {
       Printf("%zu bytes inside of", offset);
@@ -232,7 +232,7 @@ struct AsanChunk: public ChunkBase {
   }
 };
 
-static AsanChunk *PtrToChunk(uintptr_t ptr) {
+static AsanChunk *PtrToChunk(uptr ptr) {
   AsanChunk *m = (AsanChunk*)(ptr - REDZONE);
   if (m->chunk_state == CHUNK_MEMALIGN) {
     m = m->next;
@@ -261,7 +261,7 @@ void AsanChunkFifoList::PushList(AsanChunkFifoList *q) {
 }
 
 void AsanChunkFifoList::Push(AsanChunk *n) {
-  CHECK(n->next == NULL);
+  CHECK(n->next == 0);
   if (last_) {
     CHECK(first_);
     CHECK(!last_->next);
@@ -281,8 +281,8 @@ AsanChunk *AsanChunkFifoList::Pop() {
   CHECK(first_);
   AsanChunk *res = first_;
   first_ = first_->next;
-  if (first_ == NULL)
-    last_ = NULL;
+  if (first_ == 0)
+    last_ = 0;
   CHECK(size_ >= res->Size());
   size_ -= res->Size();
   if (last_) {
@@ -293,11 +293,11 @@ AsanChunk *AsanChunkFifoList::Pop() {
 
 // All pages we ever allocated.
 struct PageGroup {
-  uintptr_t beg;
-  uintptr_t end;
-  size_t size_of_chunk;
-  uintptr_t last_chunk;
-  bool InRange(uintptr_t addr) {
+  uptr beg;
+  uptr end;
+  uptr size_of_chunk;
+  uptr last_chunk;
+  bool InRange(uptr addr) {
     return addr >= beg && addr < end;
   }
 };
@@ -307,12 +307,12 @@ class MallocInfo {
 
   explicit MallocInfo(LinkerInitialized x) : mu_(x) { }
 
-  AsanChunk *AllocateChunks(uint8_t size_class, size_t n_chunks) {
-    AsanChunk *m = NULL;
+  AsanChunk *AllocateChunks(uint8_t size_class, uptr n_chunks) {
+    AsanChunk *m = 0;
     AsanChunk **fl = &free_lists_[size_class];
     {
       ScopedLock lock(&mu_);
-      for (size_t i = 0; i < n_chunks; i++) {
+      for (uptr i = 0; i < n_chunks; i++) {
         if (!(*fl)) {
           *fl = GetNewChunks(size_class);
         }
@@ -338,7 +338,7 @@ class MallocInfo {
       }
     }
     if (eat_free_lists) {
-      for (size_t size_class = 0; size_class < kNumberOfSizeClasses;
+      for (uptr size_class = 0; size_class < kNumberOfSizeClasses;
            size_class++) {
         AsanChunk *m = x->free_lists_[size_class];
         while (m) {
@@ -357,12 +357,12 @@ class MallocInfo {
     quarantine_.Push(chunk);
   }
 
-  AsanChunk *FindMallocedOrFreed(uintptr_t addr, size_t access_size) {
+  AsanChunk *FindMallocedOrFreed(uptr addr, uptr access_size) {
     ScopedLock lock(&mu_);
     return FindChunkByAddr(addr);
   }
 
-  size_t AllocationSize(uintptr_t ptr) {
+  uptr AllocationSize(uptr ptr) {
     if (!ptr) return 0;
     ScopedLock lock(&mu_);
 
@@ -387,14 +387,14 @@ class MallocInfo {
 
   void PrintStatus() {
     ScopedLock lock(&mu_);
-    size_t malloced = 0;
+    uptr malloced = 0;
 
     Printf(" MallocInfo: in quarantine: %zu malloced: %zu; ",
            quarantine_.size() >> 20, malloced >> 20);
-    for (size_t j = 1; j < kNumberOfSizeClasses; j++) {
+    for (uptr j = 1; j < kNumberOfSizeClasses; j++) {
       AsanChunk *i = free_lists_[j];
       if (!i) continue;
-      size_t t = 0;
+      uptr t = 0;
       for (; i; i = i->next) {
         t += i->Size();
       }
@@ -403,24 +403,24 @@ class MallocInfo {
     Printf("\n");
   }
 
-  PageGroup *FindPageGroup(uintptr_t addr) {
+  PageGroup *FindPageGroup(uptr addr) {
     ScopedLock lock(&mu_);
     return FindPageGroupUnlocked(addr);
   }
 
  private:
-  PageGroup *FindPageGroupUnlocked(uintptr_t addr) {
+  PageGroup *FindPageGroupUnlocked(uptr addr) {
     int n = n_page_groups_;
     // If the page groups are not sorted yet, sort them.
     if (n_sorted_page_groups_ < n) {
-      SortArray((uintptr_t*)page_groups_, n);
+      SortArray((uptr*)page_groups_, n);
       n_sorted_page_groups_ = n;
     }
     // Binary search over the page groups.
     int beg = 0, end = n;
     while (beg < end) {
       int med = (beg + end) / 2;
-      uintptr_t g = (uintptr_t)page_groups_[med];
+      uptr g = (uptr)page_groups_[med];
       if (addr > g) {
         // 'g' points to the end of the group, so 'addr'
         // may not belong to page_groups_[med] or any previous group.
@@ -431,16 +431,16 @@ class MallocInfo {
       }
     }
     if (beg >= n)
-      return NULL;
+      return 0;
     PageGroup *g = page_groups_[beg];
     CHECK(g);
     if (g->InRange(addr))
       return g;
-    return NULL;
+    return 0;
   }
 
   // We have an address between two chunks, and we want to report just one.
-  AsanChunk *ChooseChunk(uintptr_t addr,
+  AsanChunk *ChooseChunk(uptr addr,
                          AsanChunk *left_chunk, AsanChunk *right_chunk) {
     // Prefer an allocated chunk or a chunk from quarantine.
     if (left_chunk->chunk_state == CHUNK_AVAILABLE &&
@@ -450,7 +450,7 @@ class MallocInfo {
         left_chunk->chunk_state != CHUNK_AVAILABLE)
       return left_chunk;
     // Choose based on offset.
-    size_t l_offset = 0, r_offset = 0;
+    uptr l_offset = 0, r_offset = 0;
     CHECK(left_chunk->AddrIsAtRight(addr, 1, &l_offset));
     CHECK(right_chunk->AddrIsAtLeft(addr, 1, &r_offset));
     if (l_offset < r_offset)
@@ -458,33 +458,33 @@ class MallocInfo {
     return right_chunk;
   }
 
-  AsanChunk *FindChunkByAddr(uintptr_t addr) {
+  AsanChunk *FindChunkByAddr(uptr addr) {
     PageGroup *g = FindPageGroupUnlocked(addr);
     if (!g) return 0;
     CHECK(g->size_of_chunk);
-    uintptr_t offset_from_beg = addr - g->beg;
-    uintptr_t this_chunk_addr = g->beg +
+    uptr offset_from_beg = addr - g->beg;
+    uptr this_chunk_addr = g->beg +
         (offset_from_beg / g->size_of_chunk) * g->size_of_chunk;
     CHECK(g->InRange(this_chunk_addr));
     AsanChunk *m = (AsanChunk*)this_chunk_addr;
     CHECK(m->chunk_state == CHUNK_ALLOCATED ||
           m->chunk_state == CHUNK_AVAILABLE ||
           m->chunk_state == CHUNK_QUARANTINE);
-    size_t offset = 0;
+    uptr offset = 0;
     if (m->AddrIsInside(addr, 1, &offset))
       return m;
 
     if (m->AddrIsAtRight(addr, 1, &offset)) {
       if (this_chunk_addr == g->last_chunk)  // rightmost chunk
         return m;
-      uintptr_t right_chunk_addr = this_chunk_addr + g->size_of_chunk;
+      uptr right_chunk_addr = this_chunk_addr + g->size_of_chunk;
       CHECK(g->InRange(right_chunk_addr));
       return ChooseChunk(addr, m, (AsanChunk*)right_chunk_addr);
     } else {
       CHECK(m->AddrIsAtLeft(addr, 1, &offset));
       if (this_chunk_addr == g->beg)  // leftmost chunk
         return m;
-      uintptr_t left_chunk_addr = this_chunk_addr - g->size_of_chunk;
+      uptr left_chunk_addr = this_chunk_addr - g->size_of_chunk;
       CHECK(g->InRange(left_chunk_addr));
       return ChooseChunk(addr, (AsanChunk*)left_chunk_addr, m);
     }
@@ -498,11 +498,11 @@ class MallocInfo {
 
     CHECK(m->chunk_state == CHUNK_QUARANTINE);
     m->chunk_state = CHUNK_AVAILABLE;
-    PoisonShadow((uintptr_t)m, m->Size(), kAsanHeapLeftRedzoneMagic);
+    PoisonShadow((uptr)m, m->Size(), kAsanHeapLeftRedzoneMagic);
     CHECK(m->alloc_tid >= 0);
     CHECK(m->free_tid >= 0);
 
-    size_t size_class = m->SizeClass();
+    uptr size_class = m->SizeClass();
     m->next = free_lists_[size_class];
     free_lists_[size_class] = m;
 
@@ -516,11 +516,11 @@ class MallocInfo {
 
   // Get a list of newly allocated chunks.
   AsanChunk *GetNewChunks(uint8_t size_class) {
-    size_t size = SizeClassToSize(size_class);
+    uptr size = SizeClassToSize(size_class);
     CHECK(IsPowerOfTwo(kMinMmapSize));
     CHECK(size < kMinMmapSize || (size % kMinMmapSize) == 0);
-    size_t mmap_size = Max(size, kMinMmapSize);
-    size_t n_chunks = mmap_size / size;
+    uptr mmap_size = Max(size, kMinMmapSize);
+    uptr n_chunks = mmap_size / size;
     CHECK(n_chunks * size == mmap_size);
     if (size < kPageSize) {
       // Size is small, just poison the last chunk.
@@ -538,8 +538,8 @@ class MallocInfo {
     thread_stats.mmaped += mmap_size;
     thread_stats.mmaped_by_size[size_class] += n_chunks;
 
-    AsanChunk *res = NULL;
-    for (size_t i = 0; i < n_chunks; i++) {
+    AsanChunk *res = 0;
+    for (uptr i = 0; i < n_chunks; i++) {
       AsanChunk *m = (AsanChunk*)(mem + i * size);
       m->chunk_state = CHUNK_AVAILABLE;
       m->size_class = size_class;
@@ -548,10 +548,10 @@ class MallocInfo {
     }
     PageGroup *pg = (PageGroup*)(mem + n_chunks * size);
     // This memory is already poisoned, no need to poison it again.
-    pg->beg = (uintptr_t)mem;
+    pg->beg = (uptr)mem;
     pg->end = pg->beg + mmap_size;
     pg->size_of_chunk = size;
-    pg->last_chunk = (uintptr_t)(mem + size * (n_chunks - 1));
+    pg->last_chunk = (uptr)(mem + size * (n_chunks - 1));
     int page_group_idx = AtomicInc(&n_page_groups_) - 1;
     CHECK(page_group_idx < (int)ASAN_ARRAY_SIZE(page_groups_));
     page_groups_[page_group_idx] = pg;
@@ -573,7 +573,7 @@ void AsanThreadLocalMallocStorage::CommitBack() {
   malloc_info.SwallowThreadLocalMallocStorage(this, true);
 }
 
-static void Describe(uintptr_t addr, size_t access_size) {
+static void Describe(uptr addr, uptr access_size) {
   AsanChunk *m = malloc_info.FindMallocedOrFreed(addr, access_size);
   if (!m) return;
   m->DescribeAddress(addr, access_size);
@@ -608,15 +608,15 @@ static void Describe(uintptr_t addr, size_t access_size) {
   }
 }
 
-static uint8_t *Allocate(size_t alignment, size_t size, AsanStackTrace *stack) {
+static uint8_t *Allocate(uptr alignment, uptr size, AsanStackTrace *stack) {
   __asan_init();
   CHECK(stack);
   if (size == 0) {
     size = 1;  // TODO(kcc): do something smarter
   }
   CHECK(IsPowerOfTwo(alignment));
-  size_t rounded_size = RoundUpTo(size, REDZONE);
-  size_t needed_size = rounded_size + REDZONE;
+  uptr rounded_size = RoundUpTo(size, REDZONE);
+  uptr needed_size = rounded_size + REDZONE;
   if (alignment > REDZONE) {
     needed_size += alignment;
   }
@@ -627,7 +627,7 @@ static uint8_t *Allocate(size_t alignment, size_t size, AsanStackTrace *stack) {
   }
 
   uint8_t size_class = SizeToSizeClass(needed_size);
-  size_t size_to_allocate = SizeClassToSize(size_class);
+  uptr size_to_allocate = SizeClassToSize(size_class);
   CHECK(size_to_allocate >= kMinAllocSize);
   CHECK(size_to_allocate >= needed_size);
   CHECK(IsAligned(size_to_allocate, REDZONE));
@@ -645,7 +645,7 @@ static uint8_t *Allocate(size_t alignment, size_t size, AsanStackTrace *stack) {
   thread_stats.malloced_redzones += size_to_allocate - size;
   thread_stats.malloced_by_size[size_class]++;
 
-  AsanChunk *m = NULL;
+  AsanChunk *m = 0;
   if (!t || size_to_allocate >= kMaxSizeForThreadLocalFreeList) {
     // get directly from global storage.
     m = malloc_info.AllocateChunks(size_class, 1);
@@ -654,7 +654,7 @@ static uint8_t *Allocate(size_t alignment, size_t size, AsanStackTrace *stack) {
     // get from the thread-local storage.
     AsanChunk **fl = &t->malloc_storage().free_lists_[size_class];
     if (!*fl) {
-      size_t n_new_chunks = kMaxSizeForThreadLocalFreeList / size_to_allocate;
+      uptr n_new_chunks = kMaxSizeForThreadLocalFreeList / size_to_allocate;
       *fl = malloc_info.AllocateChunks(size_class, n_new_chunks);
       thread_stats.malloc_small_slow++;
     }
@@ -664,10 +664,10 @@ static uint8_t *Allocate(size_t alignment, size_t size, AsanStackTrace *stack) {
   CHECK(m);
   CHECK(m->chunk_state == CHUNK_AVAILABLE);
   m->chunk_state = CHUNK_ALLOCATED;
-  m->next = NULL;
+  m->next = 0;
   CHECK(m->Size() == size_to_allocate);
-  uintptr_t addr = (uintptr_t)m + REDZONE;
-  CHECK(addr == (uintptr_t)m->compressed_free_stack());
+  uptr addr = (uptr)m + REDZONE;
+  CHECK(addr == (uptr)m->compressed_free_stack());
 
   if (alignment > REDZONE && (addr & (alignment - 1))) {
     addr = RoundUpTo(addr, alignment);
@@ -678,7 +678,7 @@ static uint8_t *Allocate(size_t alignment, size_t size, AsanStackTrace *stack) {
   }
   CHECK(m == PtrToChunk(addr));
   m->used_size = size;
-  m->offset = addr - (uintptr_t)m;
+  m->offset = addr - (uptr)m;
   CHECK(m->beg() == addr);
   m->alloc_tid = t ? t->tid() : 0;
   m->free_tid   = AsanThread::kInvalidTid;
@@ -700,11 +700,11 @@ static void Deallocate(uint8_t *ptr, AsanStackTrace *stack) {
   CHECK(stack);
 
   if (FLAG_debug) {
-    CHECK(malloc_info.FindPageGroup((uintptr_t)ptr));
+    CHECK(malloc_info.FindPageGroup((uptr)ptr));
   }
 
   // Printf("Deallocate %p\n", ptr);
-  AsanChunk *m = PtrToChunk((uintptr_t)ptr);
+  AsanChunk *m = PtrToChunk((uptr)ptr);
 
   // Flip the state atomically to avoid race on double-free.
   uint16_t old_chunk_state = AtomicExchange(&m->chunk_state, CHUNK_QUARANTINE);
@@ -712,7 +712,7 @@ static void Deallocate(uint8_t *ptr, AsanStackTrace *stack) {
   if (old_chunk_state == CHUNK_QUARANTINE) {
     Report("ERROR: AddressSanitizer attempting double-free on %p:\n", ptr);
     stack->PrintStack();
-    Describe((uintptr_t)ptr, 1);
+    Describe((uptr)ptr, 1);
     ShowStatsAndAbort();
   } else if (old_chunk_state != CHUNK_ALLOCATED) {
     Report("ERROR: AddressSanitizer attempting free on address which was not"
@@ -727,8 +727,8 @@ static void Deallocate(uint8_t *ptr, AsanStackTrace *stack) {
   m->free_tid = t ? t->tid() : 0;
   AsanStackTrace::CompressStack(stack, m->compressed_free_stack(),
                                 m->compressed_free_stack_size());
-  size_t rounded_size = RoundUpTo(m->used_size, REDZONE);
-  PoisonShadow((uintptr_t)ptr, rounded_size, kAsanHeapFreeMagic);
+  uptr rounded_size = RoundUpTo(m->used_size, REDZONE);
+  PoisonShadow((uptr)ptr, rounded_size, kAsanHeapFreeMagic);
 
   // Statistics.
   AsanStats &thread_stats = asanThreadRegistry().GetCurrentThreadStats();
@@ -751,7 +751,7 @@ static void Deallocate(uint8_t *ptr, AsanStackTrace *stack) {
   }
 }
 
-static uint8_t *Reallocate(uint8_t *old_ptr, size_t new_size,
+static uint8_t *Reallocate(uint8_t *old_ptr, uptr new_size,
                            AsanStackTrace *stack) {
   CHECK(old_ptr && new_size);
 
@@ -760,13 +760,13 @@ static uint8_t *Reallocate(uint8_t *old_ptr, size_t new_size,
   thread_stats.reallocs++;
   thread_stats.realloced += new_size;
 
-  AsanChunk *m = PtrToChunk((uintptr_t)old_ptr);
+  AsanChunk *m = PtrToChunk((uptr)old_ptr);
   CHECK(m->chunk_state == CHUNK_ALLOCATED);
-  size_t old_size = m->used_size;
-  size_t memcpy_size = Min(new_size, old_size);
+  uptr old_size = m->used_size;
+  uptr memcpy_size = Min(new_size, old_size);
   uint8_t *new_ptr = Allocate(0, new_size, stack);
   if (new_ptr) {
-    CHECK(REAL(memcpy) != NULL);
+    CHECK(REAL(memcpy) != 0);
     REAL(memcpy)(new_ptr, old_ptr, memcpy_size);
     Deallocate(old_ptr, stack);
   }
@@ -784,9 +784,9 @@ static uint8_t *Reallocate(uint8_t *old_ptr, size_t new_size,
 // program must provide implementation of this hook.
 // If macro is undefined, the hook is no-op.
 #ifdef ASAN_NEW_HOOK
-extern "C" void ASAN_NEW_HOOK(void *ptr, size_t size);
+extern "C" void ASAN_NEW_HOOK(void *ptr, uptr size);
 #else
-static inline void ASAN_NEW_HOOK(void *ptr, size_t size) { }
+static inline void ASAN_NEW_HOOK(void *ptr, uptr size) { }
 #endif
 
 #ifdef ASAN_DELETE_HOOK
@@ -797,7 +797,7 @@ static inline void ASAN_DELETE_HOOK(void *ptr) { }
 
 namespace __asan {
 
-void *asan_memalign(size_t alignment, size_t size, AsanStackTrace *stack) {
+void *asan_memalign(uptr alignment, uptr size, AsanStackTrace *stack) {
   void *ptr = (void*)Allocate(alignment, size, stack);
   ASAN_NEW_HOOK(ptr, size);
   return ptr;
@@ -808,13 +808,13 @@ void asan_free(void *ptr, AsanStackTrace *stack) {
   Deallocate((uint8_t*)ptr, stack);
 }
 
-void *asan_malloc(size_t size, AsanStackTrace *stack) {
+void *asan_malloc(uptr size, AsanStackTrace *stack) {
   void *ptr = (void*)Allocate(0, size, stack);
   ASAN_NEW_HOOK(ptr, size);
   return ptr;
 }
 
-void *asan_calloc(size_t nmemb, size_t size, AsanStackTrace *stack) {
+void *asan_calloc(uptr nmemb, uptr size, AsanStackTrace *stack) {
   void *ptr = (void*)Allocate(0, nmemb * size, stack);
   if (ptr)
     REAL(memset)(ptr, 0, nmemb * size);
@@ -822,26 +822,26 @@ void *asan_calloc(size_t nmemb, size_t size, AsanStackTrace *stack) {
   return ptr;
 }
 
-void *asan_realloc(void *p, size_t size, AsanStackTrace *stack) {
-  if (p == NULL) {
+void *asan_realloc(void *p, uptr size, AsanStackTrace *stack) {
+  if (p == 0) {
     void *ptr = (void*)Allocate(0, size, stack);
     ASAN_NEW_HOOK(ptr, size);
     return ptr;
   } else if (size == 0) {
     ASAN_DELETE_HOOK(p);
     Deallocate((uint8_t*)p, stack);
-    return NULL;
+    return 0;
   }
   return Reallocate((uint8_t*)p, size, stack);
 }
 
-void *asan_valloc(size_t size, AsanStackTrace *stack) {
+void *asan_valloc(uptr size, AsanStackTrace *stack) {
   void *ptr = (void*)Allocate(kPageSize, size, stack);
   ASAN_NEW_HOOK(ptr, size);
   return ptr;
 }
 
-void *asan_pvalloc(size_t size, AsanStackTrace *stack) {
+void *asan_pvalloc(uptr size, AsanStackTrace *stack) {
   size = RoundUpTo(size, kPageSize);
   if (size == 0) {
     // pvalloc(0) should allocate one page.
@@ -852,34 +852,34 @@ void *asan_pvalloc(size_t size, AsanStackTrace *stack) {
   return ptr;
 }
 
-int asan_posix_memalign(void **memptr, size_t alignment, size_t size,
+int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                           AsanStackTrace *stack) {
   void *ptr = Allocate(alignment, size, stack);
-  CHECK(IsAligned((uintptr_t)ptr, alignment));
+  CHECK(IsAligned((uptr)ptr, alignment));
   ASAN_NEW_HOOK(ptr, size);
   *memptr = ptr;
   return 0;
 }
 
-size_t asan_malloc_usable_size(void *ptr, AsanStackTrace *stack) {
+uptr asan_malloc_usable_size(void *ptr, AsanStackTrace *stack) {
   CHECK(stack);
-  if (ptr == NULL) return 0;
-  size_t usable_size = malloc_info.AllocationSize((uintptr_t)ptr);
+  if (ptr == 0) return 0;
+  uptr usable_size = malloc_info.AllocationSize((uptr)ptr);
   if (FLAG_check_malloc_usable_size && (usable_size == 0)) {
     Report("ERROR: AddressSanitizer attempting to call malloc_usable_size() "
            "for pointer which is not owned: %p\n", ptr);
     stack->PrintStack();
-    Describe((uintptr_t)ptr, 1);
+    Describe((uptr)ptr, 1);
     ShowStatsAndAbort();
   }
   return usable_size;
 }
 
-size_t asan_mz_size(const void *ptr) {
-  return malloc_info.AllocationSize((uintptr_t)ptr);
+uptr asan_mz_size(const void *ptr) {
+  return malloc_info.AllocationSize((uptr)ptr);
 }
 
-void DescribeHeapAddress(uintptr_t addr, uintptr_t access_size) {
+void DescribeHeapAddress(uptr addr, uptr access_size) {
   Describe(addr, access_size);
 }
 
@@ -893,34 +893,34 @@ void asan_mz_force_unlock() {
 
 // ---------------------- Fake stack-------------------- {{{1
 FakeStack::FakeStack() {
-  CHECK(REAL(memset) != NULL);
+  CHECK(REAL(memset) != 0);
   REAL(memset)(this, 0, sizeof(*this));
 }
 
-bool FakeStack::AddrIsInSizeClass(uintptr_t addr, size_t size_class) {
-  uintptr_t mem = allocated_size_classes_[size_class];
-  uintptr_t size = ClassMmapSize(size_class);
+bool FakeStack::AddrIsInSizeClass(uptr addr, uptr size_class) {
+  uptr mem = allocated_size_classes_[size_class];
+  uptr size = ClassMmapSize(size_class);
   bool res = mem && addr >= mem && addr < mem + size;
   return res;
 }
 
-uintptr_t FakeStack::AddrIsInFakeStack(uintptr_t addr) {
-  for (size_t i = 0; i < kNumberOfSizeClasses; i++) {
+uptr FakeStack::AddrIsInFakeStack(uptr addr) {
+  for (uptr i = 0; i < kNumberOfSizeClasses; i++) {
     if (AddrIsInSizeClass(addr, i)) return allocated_size_classes_[i];
   }
   return 0;
 }
 
 // We may want to compute this during compilation.
-inline size_t FakeStack::ComputeSizeClass(size_t alloc_size) {
-  size_t rounded_size = RoundUpToPowerOfTwo(alloc_size);
-  size_t log = Log2(rounded_size);
+inline uptr FakeStack::ComputeSizeClass(uptr alloc_size) {
+  uptr rounded_size = RoundUpToPowerOfTwo(alloc_size);
+  uptr log = Log2(rounded_size);
   CHECK(alloc_size <= (1UL << log));
   if (!(alloc_size > (1UL << (log-1)))) {
     Printf("alloc_size %zu log %zu\n", alloc_size, log);
   }
   CHECK(alloc_size > (1UL << (log-1)));
-  size_t res = log < kMinStackFrameSizeLog ? 0 : log - kMinStackFrameSizeLog;
+  uptr res = log < kMinStackFrameSizeLog ? 0 : log - kMinStackFrameSizeLog;
   CHECK(res < kNumberOfSizeClasses);
   CHECK(ClassSize(res) >= rounded_size);
   return res;
@@ -952,15 +952,15 @@ FakeFrame *FakeFrameFifo::FifoPop() {
   return res;
 }
 
-void FakeStack::Init(size_t stack_size) {
+void FakeStack::Init(uptr stack_size) {
   stack_size_ = stack_size;
   alive_ = true;
 }
 
 void FakeStack::Cleanup() {
   alive_ = false;
-  for (size_t i = 0; i < kNumberOfSizeClasses; i++) {
-    uintptr_t mem = allocated_size_classes_[i];
+  for (uptr i = 0; i < kNumberOfSizeClasses; i++) {
+    uptr mem = allocated_size_classes_[i];
     if (mem) {
       PoisonShadow(mem, ClassMmapSize(i), 0);
       allocated_size_classes_[i] = 0;
@@ -969,19 +969,19 @@ void FakeStack::Cleanup() {
   }
 }
 
-size_t FakeStack::ClassMmapSize(size_t size_class) {
+uptr FakeStack::ClassMmapSize(uptr size_class) {
   return RoundUpToPowerOfTwo(stack_size_);
 }
 
-void FakeStack::AllocateOneSizeClass(size_t size_class) {
+void FakeStack::AllocateOneSizeClass(uptr size_class) {
   CHECK(ClassMmapSize(size_class) >= kPageSize);
-  uintptr_t new_mem = (uintptr_t)AsanMmapSomewhereOrDie(
+  uptr new_mem = (uptr)AsanMmapSomewhereOrDie(
       ClassMmapSize(size_class), __FUNCTION__);
   // Printf("T%d new_mem[%zu]: %p-%p mmap %zu\n",
   //       asanThreadRegistry().GetCurrent()->tid(),
   //       size_class, new_mem, new_mem + ClassMmapSize(size_class),
   //       ClassMmapSize(size_class));
-  size_t i;
+  uptr i;
   for (i = 0; i < ClassMmapSize(size_class);
        i += ClassSize(size_class)) {
     size_classes_[size_class].FifoPush((FakeFrame*)(new_mem + i));
@@ -990,10 +990,10 @@ void FakeStack::AllocateOneSizeClass(size_t size_class) {
   allocated_size_classes_[size_class] = new_mem;
 }
 
-uintptr_t FakeStack::AllocateStack(size_t size, size_t real_stack) {
+uptr FakeStack::AllocateStack(uptr size, uptr real_stack) {
   if (!alive_) return real_stack;
   CHECK(size <= kMaxStackMallocSize && size > 1);
-  size_t size_class = ComputeSizeClass(size);
+  uptr size_class = ComputeSizeClass(size);
   if (!allocated_size_classes_[size_class]) {
     AllocateOneSizeClass(size_class);
   }
@@ -1007,23 +1007,23 @@ uintptr_t FakeStack::AllocateStack(size_t size, size_t real_stack) {
     DeallocateFrame(top);
   }
   call_stack_.LifoPush(fake_frame);
-  uintptr_t ptr = (uintptr_t)fake_frame;
+  uptr ptr = (uptr)fake_frame;
   PoisonShadow(ptr, size, 0);
   return ptr;
 }
 
 void FakeStack::DeallocateFrame(FakeFrame *fake_frame) {
   CHECK(alive_);
-  size_t size = fake_frame->size_minus_one + 1;
-  size_t size_class = ComputeSizeClass(size);
+  uptr size = fake_frame->size_minus_one + 1;
+  uptr size_class = ComputeSizeClass(size);
   CHECK(allocated_size_classes_[size_class]);
-  uintptr_t ptr = (uintptr_t)fake_frame;
+  uptr ptr = (uptr)fake_frame;
   CHECK(AddrIsInSizeClass(ptr, size_class));
   CHECK(AddrIsInSizeClass(ptr + size - 1, size_class));
   size_classes_[size_class].FifoPush(fake_frame);
 }
 
-void FakeStack::OnFree(size_t ptr, size_t size, size_t real_stack) {
+void FakeStack::OnFree(uptr ptr, uptr size, uptr real_stack) {
   FakeFrame *fake_frame = (FakeFrame*)ptr;
   CHECK(fake_frame->magic = kRetiredStackFrameMagic);
   CHECK(fake_frame->descr != 0);
@@ -1036,19 +1036,19 @@ void FakeStack::OnFree(size_t ptr, size_t size, size_t real_stack) {
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;  // NOLINT
 
-uptr __asan_stack_malloc(size_t size, size_t real_stack) {
+uptr __asan_stack_malloc(uptr size, uptr real_stack) {
   if (!FLAG_use_fake_stack) return real_stack;
   AsanThread *t = asanThreadRegistry().GetCurrent();
   if (!t) {
     // TSD is gone, use the real stack.
     return real_stack;
   }
-  size_t ptr = t->fake_stack().AllocateStack(size, real_stack);
+  uptr ptr = t->fake_stack().AllocateStack(size, real_stack);
   // Printf("__asan_stack_malloc %p %zu %p\n", ptr, size, real_stack);
   return ptr;
 }
 
-void __asan_stack_free(size_t ptr, size_t size, size_t real_stack) {
+void __asan_stack_free(uptr ptr, uptr size, uptr real_stack) {
   if (!FLAG_use_fake_stack) return;
   if (ptr != real_stack) {
     FakeStack::OnFree(ptr, size, real_stack);
@@ -1063,19 +1063,19 @@ uptr __asan_get_estimated_allocated_size(uptr size) {
 }
 
 bool __asan_get_ownership(const void *p) {
-  return malloc_info.AllocationSize((uintptr_t)p) > 0;
+  return malloc_info.AllocationSize((uptr)p) > 0;
 }
 
 uptr __asan_get_allocated_size(const void *p) {
-  if (p == NULL) return 0;
-  size_t allocated_size = malloc_info.AllocationSize((uintptr_t)p);
+  if (p == 0) return 0;
+  uptr allocated_size = malloc_info.AllocationSize((uptr)p);
   // Die if p is not malloced or if it is already freed.
   if (allocated_size == 0) {
     Report("ERROR: AddressSanitizer attempting to call "
            "__asan_get_allocated_size() for pointer which is "
            "not owned: %p\n", p);
     PRINT_CURRENT_STACK();
-    Describe((uintptr_t)p, 1);
+    Describe((uptr)p, 1);
     ShowStatsAndAbort();
   }
   return allocated_size;
diff --git a/compiler-rt/lib/asan/asan_allocator.h b/compiler-rt/lib/asan/asan_allocator.h
index cc6ac8487d5..eee59012284 100644
--- a/compiler-rt/lib/asan/asan_allocator.h
+++ b/compiler-rt/lib/asan/asan_allocator.h
@@ -20,7 +20,7 @@
 
 namespace __asan {
 
-static const size_t kNumberOfSizeClasses = 255;
+static const uptr kNumberOfSizeClasses = 255;
 struct AsanChunk;
 
 class AsanChunkFifoList {
@@ -30,15 +30,15 @@ class AsanChunkFifoList {
   void Push(AsanChunk *n);
   void PushList(AsanChunkFifoList *q);
   AsanChunk *Pop();
-  size_t size() { return size_; }
+  uptr size() { return size_; }
   void clear() {
-    first_ = last_ = NULL;
+    first_ = last_ = 0;
     size_ = 0;
   }
  private:
   AsanChunk *first_;
   AsanChunk *last_;
-  size_t size_;
+  uptr size_;
 };
 
 struct AsanThreadLocalMallocStorage {
@@ -57,8 +57,8 @@ struct AsanThreadLocalMallocStorage {
 // Fake stack frame contains local variables of one function.
 // This struct should fit into a stack redzone (32 bytes).
 struct FakeFrame {
-  uintptr_t magic;  // Modified by the instrumented code.
-  uintptr_t descr;  // Modified by the instrumented code.
+  uptr magic;  // Modified by the instrumented code.
+  uptr descr;  // Modified by the instrumented code.
   FakeFrame *next;
   uint64_t real_stack     : 48;
   uint64_t size_minus_one : 16;
@@ -100,60 +100,60 @@ class FakeStack {
  public:
   FakeStack();
   explicit FakeStack(LinkerInitialized) {}
-  void Init(size_t stack_size);
+  void Init(uptr stack_size);
   void StopUsingFakeStack() { alive_ = false; }
   void Cleanup();
-  uintptr_t AllocateStack(size_t size, size_t real_stack);
-  static void OnFree(size_t ptr, size_t size, size_t real_stack);
+  uptr AllocateStack(uptr size, uptr real_stack);
+  static void OnFree(uptr ptr, uptr size, uptr real_stack);
   // Return the bottom of the maped region.
-  uintptr_t AddrIsInFakeStack(uintptr_t addr);
+  uptr AddrIsInFakeStack(uptr addr);
   bool StackSize() { return stack_size_; }
  private:
-  static const size_t kMinStackFrameSizeLog = 9;  // Min frame is 512B.
-  static const size_t kMaxStackFrameSizeLog = 16;  // Max stack frame is 64K.
-  static const size_t kMaxStackMallocSize = 1 << kMaxStackFrameSizeLog;
-  static const size_t kNumberOfSizeClasses =
+  static const uptr kMinStackFrameSizeLog = 9;  // Min frame is 512B.
+  static const uptr kMaxStackFrameSizeLog = 16;  // Max stack frame is 64K.
+  static const uptr kMaxStackMallocSize = 1 << kMaxStackFrameSizeLog;
+  static const uptr kNumberOfSizeClasses =
       kMaxStackFrameSizeLog - kMinStackFrameSizeLog + 1;
 
-  bool AddrIsInSizeClass(uintptr_t addr, size_t size_class);
+  bool AddrIsInSizeClass(uptr addr, uptr size_class);
 
   // Each size class should be large enough to hold all frames.
-  size_t ClassMmapSize(size_t size_class);
+  uptr ClassMmapSize(uptr size_class);
 
-  size_t ClassSize(size_t size_class) {
+  uptr ClassSize(uptr size_class) {
     return 1UL << (size_class + kMinStackFrameSizeLog);
   }
 
   void DeallocateFrame(FakeFrame *fake_frame);
 
-  size_t ComputeSizeClass(size_t alloc_size);
-  void AllocateOneSizeClass(size_t size_class);
+  uptr ComputeSizeClass(uptr alloc_size);
+  void AllocateOneSizeClass(uptr size_class);
 
-  size_t stack_size_;
+  uptr stack_size_;
   bool   alive_;
 
-  uintptr_t allocated_size_classes_[kNumberOfSizeClasses];
+  uptr allocated_size_classes_[kNumberOfSizeClasses];
   FakeFrameFifo size_classes_[kNumberOfSizeClasses];
   FakeFrameLifo call_stack_;
 };
 
-void *asan_memalign(size_t alignment, size_t size, AsanStackTrace *stack);
+void *asan_memalign(uptr alignment, uptr size, AsanStackTrace *stack);
 void asan_free(void *ptr, AsanStackTrace *stack);
 
-void *asan_malloc(size_t size, AsanStackTrace *stack);
-void *asan_calloc(size_t nmemb, size_t size, AsanStackTrace *stack);
-void *asan_realloc(void *p, size_t size, AsanStackTrace *stack);
-void *asan_valloc(size_t size, AsanStackTrace *stack);
-void *asan_pvalloc(size_t size, AsanStackTrace *stack);
+void *asan_malloc(uptr size, AsanStackTrace *stack);
+void *asan_calloc(uptr nmemb, uptr size, AsanStackTrace *stack);
+void *asan_realloc(void *p, uptr size, AsanStackTrace *stack);
+void *asan_valloc(uptr size, AsanStackTrace *stack);
+void *asan_pvalloc(uptr size, AsanStackTrace *stack);
 
-int asan_posix_memalign(void **memptr, size_t alignment, size_t size,
+int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                           AsanStackTrace *stack);
-size_t asan_malloc_usable_size(void *ptr, AsanStackTrace *stack);
+uptr asan_malloc_usable_size(void *ptr, AsanStackTrace *stack);
 
-size_t asan_mz_size(const void *ptr);
+uptr asan_mz_size(const void *ptr);
 void asan_mz_force_lock();
 void asan_mz_force_unlock();
-void DescribeHeapAddress(uintptr_t addr, size_t access_size);
+void DescribeHeapAddress(uptr addr, uptr access_size);
 
 }  // namespace __asan
 #endif  // ASAN_ALLOCATOR_H
diff --git a/compiler-rt/lib/asan/asan_globals.cc b/compiler-rt/lib/asan/asan_globals.cc
index 96972c19c20..713f6003e8e 100644
--- a/compiler-rt/lib/asan/asan_globals.cc
+++ b/compiler-rt/lib/asan/asan_globals.cc
@@ -36,10 +36,10 @@ static ListOfGlobals *list_of_globals;
 static LowLevelAllocator allocator_for_globals(LINKER_INITIALIZED);
 
 void PoisonRedZones(const Global &g)  {
-  size_t shadow_rz_size = kGlobalAndStackRedzone >> SHADOW_SCALE;
+  uptr shadow_rz_size = kGlobalAndStackRedzone >> SHADOW_SCALE;
   CHECK(shadow_rz_size == 1 || shadow_rz_size == 2 || shadow_rz_size == 4);
   // full right redzone
-  size_t g_aligned_size = kGlobalAndStackRedzone *
+  uptr g_aligned_size = kGlobalAndStackRedzone *
       ((g.size + kGlobalAndStackRedzone - 1) / kGlobalAndStackRedzone);
   PoisonShadow(g.beg + g_aligned_size,
                kGlobalAndStackRedzone, kAsanGlobalRedzoneMagic);
@@ -55,21 +55,21 @@ void PoisonRedZones(const Global &g)  {
   }
 }
 
-static size_t GetAlignedSize(size_t size) {
+static uptr GetAlignedSize(uptr size) {
   return ((size + kGlobalAndStackRedzone - 1) / kGlobalAndStackRedzone)
       * kGlobalAndStackRedzone;
 }
 
   // Check if the global is a zero-terminated ASCII string. If so, print it.
 void PrintIfASCII(const Global &g) {
-  for (size_t p = g.beg; p < g.beg + g.size - 1; p++) {
+  for (uptr p = g.beg; p < g.beg + g.size - 1; p++) {
     if (!isascii(*(char*)p)) return;
   }
   if (*(char*)(g.beg + g.size - 1) != 0) return;
   Printf("  '%s' is ascii string '%s'\n", g.name, g.beg);
 }
 
-bool DescribeAddrIfMyRedZone(const Global &g, uintptr_t addr) {
+bool DescribeAddrIfMyRedZone(const Global &g, uptr addr) {
   if (addr < g.beg - kGlobalAndStackRedzone) return false;
   if (addr >= g.beg + g.size_with_redzone) return false;
   Printf("%p is located ", addr);
@@ -87,7 +87,7 @@ bool DescribeAddrIfMyRedZone(const Global &g, uintptr_t addr) {
 }
 
 
-bool DescribeAddrIfGlobal(uintptr_t addr) {
+bool DescribeAddrIfGlobal(uptr addr) {
   if (!FLAG_report_globals) return false;
   ScopedLock lock(&mu_for_globals);
   bool res = false;
diff --git a/compiler-rt/lib/asan/asan_interceptors.cc b/compiler-rt/lib/asan/asan_interceptors.cc
index c68fb78a22b..4ecba152b37 100644
--- a/compiler-rt/lib/asan/asan_interceptors.cc
+++ b/compiler-rt/lib/asan/asan_interceptors.cc
@@ -61,27 +61,27 @@ void _longjmp(void *env, int value);
 # endif
 
 // string.h / strings.h
-int memcmp(const void *a1, const void *a2, size_t size);
-void* memmove(void *to, const void *from, size_t size);
-void* memcpy(void *to, const void *from, size_t size);
-void* memset(void *block, int c, size_t size);
+int memcmp(const void *a1, const void *a2, uptr size);
+void* memmove(void *to, const void *from, uptr size);
+void* memcpy(void *to, const void *from, uptr size);
+void* memset(void *block, int c, uptr size);
 char* strchr(const char *str, int c);
 # if defined(__APPLE__)
 char* index(const char *string, int c);
 # endif
 char* strcat(char *to, const char* from);  // NOLINT
 char* strcpy(char *to, const char* from);  // NOLINT
-char* strncpy(char *to, const char* from, size_t size);
+char* strncpy(char *to, const char* from, uptr size);
 int strcmp(const char *s1, const char* s2);
-int strncmp(const char *s1, const char* s2, size_t size);
+int strncmp(const char *s1, const char* s2, uptr size);
 # if !defined(_WIN32)
 int strcasecmp(const char *s1, const char *s2);
-int strncasecmp(const char *s1, const char *s2, size_t n);
+int strncasecmp(const char *s1, const char *s2, uptr n);
 char* strdup(const char *s);
 # endif
-size_t strlen(const char *s);
+uptr strlen(const char *s);
 # if ASAN_INTERCEPT_STRNLEN
-size_t strnlen(const char *s, size_t maxlen);
+uptr strnlen(const char *s, uptr maxlen);
 # endif
 
 // stdlib.h
@@ -96,7 +96,7 @@ long long strtoll(const char *nptr, char **endptr, int base);  // NOLINT
 // Windows threads.
 # if defined(_WIN32)
 __declspec(dllimport)
-void* __stdcall CreateThread(void *sec, size_t st, void* start,
+void* __stdcall CreateThread(void *sec, uptr st, void* start,
                              void *arg, DWORD fl, DWORD *id);
 # endif
 
@@ -129,7 +129,7 @@ namespace __asan {
 // checking the first and the last byte of a range.
 #define ACCESS_MEMORY_RANGE(offset, size, isWrite) do { \
   if (size > 0) { \
-    uintptr_t ptr = (uintptr_t)(offset); \
+    uptr ptr = (uptr)(offset); \
     ACCESS_ADDRESS(ptr, isWrite); \
     ACCESS_ADDRESS(ptr + (size) - 1, isWrite); \
   } \
@@ -146,8 +146,8 @@ namespace __asan {
 // Behavior of functions like "memcpy" or "strcpy" is undefined
 // if memory intervals overlap. We report error in this case.
 // Macro is used to avoid creation of new frames.
-static inline bool RangesOverlap(const char *offset1, size_t length1,
-                                 const char *offset2, size_t length2) {
+static inline bool RangesOverlap(const char *offset1, uptr length1,
+                                 const char *offset2, uptr length2) {
   return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1));
 }
 #define CHECK_RANGES_OVERLAP(name, _offset1, length1, _offset2, length2) do { \
@@ -205,7 +205,7 @@ int64_t internal_simple_strtoll(const char *nptr, char **endptr, int base) {
     have_digits = true;
     nptr++;
   }
-  if (endptr != NULL) {
+  if (endptr != 0) {
     *endptr = (have_digits) ? (char*)nptr : old_nptr;
   }
   if (sgn > 0) {
@@ -216,22 +216,22 @@ int64_t internal_simple_strtoll(const char *nptr, char **endptr, int base) {
 }
 
 int64_t internal_atoll(const char *nptr) {
-  return internal_simple_strtoll(nptr, (char**)NULL, 10);
+  return internal_simple_strtoll(nptr, (char**)0, 10);
 }
 
-size_t internal_strlen(const char *s) {
-  size_t i = 0;
+uptr internal_strlen(const char *s) {
+  uptr i = 0;
   while (s[i]) i++;
   return i;
 }
 
-size_t internal_strnlen(const char *s, size_t maxlen) {
+uptr internal_strnlen(const char *s, uptr maxlen) {
 #if ASAN_INTERCEPT_STRNLEN
-  if (REAL(strnlen) != NULL) {
+  if (REAL(strnlen) != 0) {
     return REAL(strnlen)(s, maxlen);
   }
 #endif
-  size_t i = 0;
+  uptr i = 0;
   while (i < maxlen && s[i]) i++;
   return i;
 }
@@ -241,36 +241,36 @@ char* internal_strchr(const char *s, int c) {
     if (*s == (char)c)
       return (char*)s;
     if (*s == 0)
-      return NULL;
+      return 0;
     s++;
   }
 }
 
-void* internal_memchr(const void* s, int c, size_t n) {
+void* internal_memchr(const void* s, int c, uptr n) {
   const char* t = (char*)s;
-  for (size_t i = 0; i < n; ++i, ++t)
+  for (uptr i = 0; i < n; ++i, ++t)
     if (*t == c)
       return (void*)t;
-  return NULL;
+  return 0;
 }
 
-int internal_memcmp(const void* s1, const void* s2, size_t n) {
+int internal_memcmp(const void* s1, const void* s2, uptr n) {
   const char* t1 = (char*)s1;
   const char* t2 = (char*)s2;
-  for (size_t i = 0; i < n; ++i, ++t1, ++t2)
+  for (uptr i = 0; i < n; ++i, ++t1, ++t2)
     if (*t1 != *t2)
       return *t1 < *t2 ? -1 : 1;
   return 0;
 }
 
 // Should not be used in performance-critical places.
-void* internal_memset(void* s, int c, size_t n) {
+void* internal_memset(void* s, int c, uptr n) {
   // The next line prevents Clang from making a call to memset() instead of the
   // loop below.
   // FIXME: building the runtime with -ffreestanding is a better idea. However
   // there currently are linktime problems due to PR12396.
   char volatile *t = (char*)s;
-  for (size_t i = 0; i < n; ++i, ++t) {
+  for (uptr i = 0; i < n; ++i, ++t) {
     *t = c;
   }
   return s;
@@ -278,19 +278,19 @@ void* internal_memset(void* s, int c, size_t n) {
 
 char *internal_strstr(const char *haystack, const char *needle) {
   // This is O(N^2), but we are not using it in hot places.
-  size_t len1 = internal_strlen(haystack);
-  size_t len2 = internal_strlen(needle);
+  uptr len1 = internal_strlen(haystack);
+  uptr len2 = internal_strlen(needle);
   if (len1 < len2) return 0;
-  for (size_t pos = 0; pos <= len1 - len2; pos++) {
+  for (uptr pos = 0; pos <= len1 - len2; pos++) {
     if (internal_memcmp(haystack + pos, needle, len2) == 0)
       return (char*)haystack + pos;
   }
   return 0;
 }
 
-char *internal_strncat(char *dst, const char *src, size_t n) {
-  size_t len = internal_strlen(dst);
-  size_t i;
+char *internal_strncat(char *dst, const char *src, uptr n) {
+  uptr len = internal_strlen(dst);
+  uptr i;
   for (i = 0; i < n && src[i]; i++)
     dst[len + i] = src[i];
   dst[len + i] = 0;
@@ -309,8 +309,8 @@ int internal_strcmp(const char *s1, const char *s2) {
   return 0;
 }
 
-char *internal_strncpy(char *dst, const char *src, size_t n) {
-  size_t i;
+char *internal_strncpy(char *dst, const char *src, uptr n) {
+  uptr i;
   for (i = 0; i < n && src[i]; i++)
     dst[i] = src[i];
   return dst;
@@ -343,7 +343,7 @@ INTERCEPTOR(void*, signal, int signum, void *handler) {
   if (!AsanInterceptsSignal(signum)) {
     return REAL(signal)(signum, handler);
   }
-  return NULL;
+  return 0;
 }
 
 INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
@@ -400,13 +400,13 @@ static void MlockIsUnsupported() {
 
 extern "C" {
 INTERCEPTOR_ATTRIBUTE
-int mlock(const void *addr, size_t len) {
+int mlock(const void *addr, uptr len) {
   MlockIsUnsupported();
   return 0;
 }
 
 INTERCEPTOR_ATTRIBUTE
-int munlock(const void *addr, size_t len) {
+int munlock(const void *addr, uptr len) {
   MlockIsUnsupported();
   return 0;
 }
@@ -434,12 +434,12 @@ static inline int CharCaseCmp(unsigned char c1, unsigned char c2) {
   return c1_low - c2_low;
 }
 
-INTERCEPTOR(int, memcmp, const void *a1, const void *a2, size_t size) {
+INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) {
   ENSURE_ASAN_INITED();
   unsigned char c1 = 0, c2 = 0;
   const unsigned char *s1 = (const unsigned char*)a1;
   const unsigned char *s2 = (const unsigned char*)a2;
-  size_t i;
+  uptr i;
   for (i = 0; i < size; i++) {
     c1 = s1[i];
     c2 = s2[i];
@@ -450,7 +450,7 @@ INTERCEPTOR(int, memcmp, const void *a1, const void *a2, size_t size) {
   return CharCmp(c1, c2);
 }
 
-INTERCEPTOR(void*, memcpy, void *to, const void *from, size_t size) {
+INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) {
   // memcpy is called during __asan_init() from the internals
   // of printf(...).
   if (asan_init_is_running) {
@@ -469,7 +469,7 @@ INTERCEPTOR(void*, memcpy, void *to, const void *from, size_t size) {
   return REAL(memcpy)(to, from, size);
 }
 
-INTERCEPTOR(void*, memmove, void *to, const void *from, size_t size) {
+INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) {
   ENSURE_ASAN_INITED();
   if (FLAG_replace_intrin) {
     ASAN_WRITE_RANGE(from, size);
@@ -478,7 +478,7 @@ INTERCEPTOR(void*, memmove, void *to, const void *from, size_t size) {
   return REAL(memmove)(to, from, size);
 }
 
-INTERCEPTOR(void*, memset, void *block, int c, size_t size) {
+INTERCEPTOR(void*, memset, void *block, int c, uptr size) {
   // memset is called inside Printf.
   if (asan_init_is_running) {
     return REAL(memset)(block, c, size);
@@ -494,7 +494,7 @@ INTERCEPTOR(char*, strchr, const char *str, int c) {
   ENSURE_ASAN_INITED();
   char *result = REAL(strchr)(str, c);
   if (FLAG_replace_str) {
-    size_t bytes_read = (result ? result - str : REAL(strlen)(str)) + 1;
+    uptr bytes_read = (result ? result - str : REAL(strlen)(str)) + 1;
     ASAN_READ_RANGE(str, bytes_read);
   }
   return result;
@@ -510,7 +510,7 @@ DEFINE_REAL(char*, index, const char *string, int c);
 INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) {
   ENSURE_ASAN_INITED();
   unsigned char c1, c2;
-  size_t i;
+  uptr i;
   for (i = 0; ; i++) {
     c1 = (unsigned char)s1[i];
     c2 = (unsigned char)s2[i];
@@ -524,10 +524,10 @@ INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) {
 INTERCEPTOR(char*, strcat, char *to, const char *from) {  // NOLINT
   ENSURE_ASAN_INITED();
   if (FLAG_replace_str) {
-    size_t from_length = REAL(strlen)(from);
+    uptr from_length = REAL(strlen)(from);
     ASAN_READ_RANGE(from, from_length + 1);
     if (from_length > 0) {
-      size_t to_length = REAL(strlen)(to);
+      uptr to_length = REAL(strlen)(to);
       ASAN_READ_RANGE(to, to_length);
       ASAN_WRITE_RANGE(to + to_length, from_length + 1);
       CHECK_RANGES_OVERLAP("strcat", to, to_length + 1, from, from_length + 1);
@@ -541,7 +541,7 @@ INTERCEPTOR(int, strcmp, const char *s1, const char *s2) {
     return internal_strcmp(s1, s2);
   }
   unsigned char c1, c2;
-  size_t i;
+  uptr i;
   for (i = 0; ; i++) {
     c1 = (unsigned char)s1[i];
     c2 = (unsigned char)s2[i];
@@ -560,7 +560,7 @@ INTERCEPTOR(char*, strcpy, char *to, const char *from) {  // NOLINT
   }
   ENSURE_ASAN_INITED();
   if (FLAG_replace_str) {
-    size_t from_size = REAL(strlen)(from) + 1;
+    uptr from_size = REAL(strlen)(from) + 1;
     CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size);
     ASAN_READ_RANGE(from, from_size);
     ASAN_WRITE_RANGE(to, from_size);
@@ -571,30 +571,30 @@ INTERCEPTOR(char*, strcpy, char *to, const char *from) {  // NOLINT
 INTERCEPTOR(char*, strdup, const char *s) {
   ENSURE_ASAN_INITED();
   if (FLAG_replace_str) {
-    size_t length = REAL(strlen)(s);
+    uptr length = REAL(strlen)(s);
     ASAN_READ_RANGE(s, length + 1);
   }
   return REAL(strdup)(s);
 }
 
-INTERCEPTOR(size_t, strlen, const char *s) {
+INTERCEPTOR(uptr, strlen, const char *s) {
   // strlen is called from malloc_default_purgeable_zone()
   // in __asan::ReplaceSystemAlloc() on Mac.
   if (asan_init_is_running) {
     return REAL(strlen)(s);
   }
   ENSURE_ASAN_INITED();
-  size_t length = REAL(strlen)(s);
+  uptr length = REAL(strlen)(s);
   if (FLAG_replace_str) {
     ASAN_READ_RANGE(s, length + 1);
   }
   return length;
 }
 
-INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, size_t n) {
+INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, uptr n) {
   ENSURE_ASAN_INITED();
   unsigned char c1 = 0, c2 = 0;
-  size_t i;
+  uptr i;
   for (i = 0; i < n; i++) {
     c1 = (unsigned char)s1[i];
     c2 = (unsigned char)s2[i];
@@ -605,14 +605,14 @@ INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, size_t n) {
   return CharCaseCmp(c1, c2);
 }
 
-INTERCEPTOR(int, strncmp, const char *s1, const char *s2, size_t size) {
+INTERCEPTOR(int, strncmp, const char *s1, const char *s2, uptr size) {
   // strncmp is called from malloc_default_purgeable_zone()
   // in __asan::ReplaceSystemAlloc() on Mac.
   if (asan_init_is_running) {
     return REAL(strncmp)(s1, s2, size);
   }
   unsigned char c1 = 0, c2 = 0;
-  size_t i;
+  uptr i;
   for (i = 0; i < size; i++) {
     c1 = (unsigned char)s1[i];
     c2 = (unsigned char)s2[i];
@@ -623,10 +623,10 @@ INTERCEPTOR(int, strncmp, const char *s1, const char *s2, size_t size) {
   return CharCmp(c1, c2);
 }
 
-INTERCEPTOR(char*, strncpy, char *to, const char *from, size_t size) {
+INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) {
   ENSURE_ASAN_INITED();
   if (FLAG_replace_str) {
-    size_t from_size = Min(size, internal_strnlen(from, size) + 1);
+    uptr from_size = Min(size, internal_strnlen(from, size) + 1);
     CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size);
     ASAN_READ_RANGE(from, from_size);
     ASAN_WRITE_RANGE(to, size);
@@ -635,9 +635,9 @@ INTERCEPTOR(char*, strncpy, char *to, const char *from, size_t size) {
 }
 
 #if ASAN_INTERCEPT_STRNLEN
-INTERCEPTOR(size_t, strnlen, const char *s, size_t maxlen) {
+INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) {
   ENSURE_ASAN_INITED();
-  size_t length = REAL(strnlen)(s, maxlen);
+  uptr length = REAL(strnlen)(s, maxlen);
   if (FLAG_replace_str) {
     ASAN_READ_RANGE(s, Min(length + 1, maxlen));
   }
@@ -650,7 +650,7 @@ static inline bool IsValidStrtolBase(int base) {
 }
 
 static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) {
-  CHECK(endptr != NULL);
+  CHECK(endptr != 0);
   if (nptr == *endptr) {
     // No digits were found at strtol call, we need to find out the last
     // symbol accessed by strtoll on our own.
@@ -670,7 +670,7 @@ INTERCEPTOR(long, strtol, const char *nptr,  // NOLINT
   }
   char *real_endptr;
   long result = REAL(strtol)(nptr, &real_endptr, base);  // NOLINT
-  if (endptr != NULL) {
+  if (endptr != 0) {
     *endptr = real_endptr;
   }
   if (IsValidStrtolBase(base)) {
@@ -687,7 +687,7 @@ INTERCEPTOR(int, atoi, const char *nptr) {
   }
   char *real_endptr;
   // "man atoi" tells that behavior of atoi(nptr) is the same as
-  // strtol(nptr, NULL, 10), i.e. it sets errno to ERANGE if the
+  // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
   // parsed integer can't be stored in *long* type (even if it's
   // different from int). So, we just imitate this behavior.
   int result = REAL(strtol)(nptr, &real_endptr, 10);
@@ -717,7 +717,7 @@ INTERCEPTOR(long long, strtoll, const char *nptr,  // NOLINT
   }
   char *real_endptr;
   long long result = REAL(strtoll)(nptr, &real_endptr, base);  // NOLINT
-  if (endptr != NULL) {
+  if (endptr != 0) {
     *endptr = real_endptr;
   }
   // If base has unsupported value, strtoll can exit with EINVAL
@@ -750,7 +750,7 @@ INTERCEPTOR(long long, atoll, const char *nptr) {  // NOLINT
 
 #if defined(_WIN32)
 INTERCEPTOR_WINAPI(DWORD, CreateThread,
-                   void* security, size_t stack_size,
+                   void* security, uptr stack_size,
                    DWORD (__stdcall *start_routine)(void*), void* arg,
                    DWORD flags, void* tid) {
   GET_STACK_TRACE_HERE(kStackTraceMax);
diff --git a/compiler-rt/lib/asan/asan_interceptors.h b/compiler-rt/lib/asan/asan_interceptors.h
index e98514ec4f3..005e7e4dbcf 100644
--- a/compiler-rt/lib/asan/asan_interceptors.h
+++ b/compiler-rt/lib/asan/asan_interceptors.h
@@ -17,13 +17,13 @@
 #include "asan_internal.h"
 #include "interception/interception.h"
 
-DECLARE_REAL(int, memcmp, const void *a1, const void *a2, size_t size);
-DECLARE_REAL(void*, memcpy, void *to, const void *from, size_t size);
-DECLARE_REAL(void*, memset, void *block, int c, size_t size);
+DECLARE_REAL(int, memcmp, const void *a1, const void *a2, uptr size);
+DECLARE_REAL(void*, memcpy, void *to, const void *from, uptr size);
+DECLARE_REAL(void*, memset, void *block, int c, uptr size);
 DECLARE_REAL(char*, strchr, const char *str, int c);
-DECLARE_REAL(size_t, strlen, const char *s);
-DECLARE_REAL(char*, strncpy, char *to, const char *from, size_t size);
-DECLARE_REAL(size_t, strnlen, const char *s, size_t maxlen);
+DECLARE_REAL(uptr, strlen, const char *s);
+DECLARE_REAL(char*, strncpy, char *to, const char *from, uptr size);
+DECLARE_REAL(uptr, strnlen, const char *s, uptr maxlen);
 struct sigaction;
 DECLARE_REAL(int, sigaction, int signum, const struct sigaction *act,
                              struct sigaction *oldact);
@@ -32,16 +32,16 @@ namespace __asan {
 
 // __asan::internal_X() is the implementation of X() for use in RTL.
 int64_t internal_atoll(const char *nptr);
-size_t internal_strlen(const char *s);
-size_t internal_strnlen(const char *s, size_t maxlen);
+uptr internal_strlen(const char *s);
+uptr internal_strnlen(const char *s, uptr maxlen);
 char* internal_strchr(const char *s, int c);
-void* internal_memchr(const void* s, int c, size_t n);
-void* internal_memset(void *s, int c, size_t n);
-int internal_memcmp(const void* s1, const void* s2, size_t n);
+void* internal_memchr(const void* s, int c, uptr n);
+void* internal_memset(void *s, int c, uptr n);
+int internal_memcmp(const void* s1, const void* s2, uptr n);
 char *internal_strstr(const char *haystack, const char *needle);
-char *internal_strncat(char *dst, const char *src, size_t n);
+char *internal_strncat(char *dst, const char *src, uptr n);
 int internal_strcmp(const char *s1, const char *s2);
-char *internal_strncpy(char *dst, const char *src, size_t n);
+char *internal_strncpy(char *dst, const char *src, uptr n);
 // Works only for base=10 and doesn't set errno.
 int64_t internal_simple_strtoll(const char *nptr, char **endptr, int base);
 
diff --git a/compiler-rt/lib/asan/asan_interface.h b/compiler-rt/lib/asan/asan_interface.h
index 794bcfeb2e7..9dc507c50b8 100644
--- a/compiler-rt/lib/asan/asan_interface.h
+++ b/compiler-rt/lib/asan/asan_interface.h
@@ -112,7 +112,7 @@ extern "C" {
       SANITIZER_INTERFACE_FUNCTION_ATTRIBUTE;
 
   // Sets the callback to be called right before death on error.
-  // Passing NULL will unset the callback.
+  // Passing 0 will unset the callback.
   void __asan_set_death_callback(void (*callback)(void))
       SANITIZER_INTERFACE_FUNCTION_ATTRIBUTE;
 
@@ -130,7 +130,7 @@ extern "C" {
   bool __asan_get_ownership(const void *p)
       SANITIZER_INTERFACE_FUNCTION_ATTRIBUTE;
   // Returns the number of bytes reserved for the pointer p.
-  // Requires (get_ownership(p) == true) or (p == NULL).
+  // Requires (get_ownership(p) == true) or (p == 0).
   uptr __asan_get_allocated_size(const void *p)
       SANITIZER_INTERFACE_FUNCTION_ATTRIBUTE;
   // Number of bytes, allocated and not yet freed by the application.
diff --git a/compiler-rt/lib/asan/asan_internal.h b/compiler-rt/lib/asan/asan_internal.h
index 68a539424d6..53d6eb28095 100644
--- a/compiler-rt/lib/asan/asan_internal.h
+++ b/compiler-rt/lib/asan/asan_internal.h
@@ -14,18 +14,17 @@
 #ifndef ASAN_INTERNAL_H
 #define ASAN_INTERNAL_H
 
+#include "sanitizer_common/sanitizer_defs.h"
 #include "sanitizer_common/sanitizer_libc.h"
 
 #if !defined(__linux__) && !defined(__APPLE__) && !defined(_WIN32)
 # error "This operating system is not supported by AddressSanitizer"
 #endif
 
-#include <stddef.h>  // for size_t, uintptr_t, etc.
-
 #if defined(_WIN32)
 # if defined(__clang__)
 typedef int              intptr_t;
-typedef unsigned int     uintptr_t;
+typedef unsigned int     uptr;
 # endif
 
 // There's no <stdint.h> in Visual Studio 9, so we have to define [u]int*_t.
@@ -160,13 +159,13 @@ void NORETURN CheckFailed(const char *cond, const char *file, int line);
 void NORETURN ShowStatsAndAbort();
 
 // asan_globals.cc
-bool DescribeAddrIfGlobal(uintptr_t addr);
+bool DescribeAddrIfGlobal(uptr addr);
 
 void ReplaceOperatorsNewAndDelete();
 // asan_malloc_linux.cc / asan_malloc_mac.cc
 void ReplaceSystemMalloc();
 
-void OutOfMemoryMessageAndDie(const char *mem_type, size_t size);
+void OutOfMemoryMessageAndDie(const char *mem_type, uptr size);
 
 // asan_linux.cc / asan_mac.cc / asan_win.cc
 void *AsanDoesNotSupportStaticLinkage();
@@ -175,17 +174,17 @@ int AsanOpenReadonly(const char* filename);
 const char *AsanGetEnv(const char *name);
 void AsanDumpProcessMap();
 
-void *AsanMmapFixedNoReserve(uintptr_t fixed_addr, size_t size);
-void *AsanMmapFixedReserve(uintptr_t fixed_addr, size_t size);
-void *AsanMprotect(uintptr_t fixed_addr, size_t size);
-void *AsanMmapSomewhereOrDie(size_t size, const char *where);
-void AsanUnmapOrDie(void *ptr, size_t size);
+void *AsanMmapFixedNoReserve(uptr fixed_addr, uptr size);
+void *AsanMmapFixedReserve(uptr fixed_addr, uptr size);
+void *AsanMprotect(uptr fixed_addr, uptr size);
+void *AsanMmapSomewhereOrDie(uptr size, const char *where);
+void AsanUnmapOrDie(void *ptr, uptr size);
 
 void AsanDisableCoreDumper();
-void GetPcSpBp(void *context, uintptr_t *pc, uintptr_t *sp, uintptr_t *bp);
+void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp);
 
-size_t AsanRead(int fd, void *buf, size_t count);
-size_t AsanWrite(int fd, const void *buf, size_t count);
+uptr AsanRead(int fd, void *buf, uptr count);
+uptr AsanWrite(int fd, const void *buf, uptr count);
 int AsanClose(int fd);
 
 bool AsanInterceptsSignal(int signum);
@@ -193,7 +192,7 @@ void SetAlternateSignalStack();
 void UnsetAlternateSignalStack();
 void InstallSignalHandlers();
 int GetPid();
-uintptr_t GetThreadSelf();
+uptr GetThreadSelf();
 int AtomicInc(int *a);
 uint16_t AtomicExchange(uint16_t *a, uint16_t new_val);
 
@@ -206,12 +205,12 @@ void AsanTSDSet(void *tsd);
 // The resulting buffer is mmaped and stored in '*buff'.
 // The size of the mmaped region is stored in '*buff_size',
 // Returns the number of read bytes or 0 if file can not be opened.
-size_t ReadFileToBuffer(const char *file_name, char **buff,
-                        size_t *buff_size, size_t max_len);
+uptr ReadFileToBuffer(const char *file_name, char **buff,
+                        uptr *buff_size, uptr max_len);
 
 // asan_printf.cc
 void RawWrite(const char *buffer);
-int SNPrintf(char *buffer, size_t length, const char *format, ...);
+int SNPrintf(char *buffer, uptr length, const char *format, ...);
 void Printf(const char *format, ...);
 int SScanf(const char *str, const char *format, ...);
 void Report(const char *format, ...);
@@ -220,16 +219,16 @@ void Report(const char *format, ...);
 template<class T> T Min(T a, T b) { return a < b ? a : b; }
 template<class T> T Max(T a, T b) { return a > b ? a : b; }
 
-void SortArray(uintptr_t *array, size_t size);
+void SortArray(uptr *array, uptr size);
 
 // asan_poisoning.cc
 // Poisons the shadow memory for "size" bytes starting from "addr".
-void PoisonShadow(uintptr_t addr, size_t size, uint8_t value);
+void PoisonShadow(uptr addr, uptr size, uint8_t value);
 // Poisons the shadow memory for "redzone_size" bytes starting from
 // "addr + size".
-void PoisonShadowPartialRightRedzone(uintptr_t addr,
-                                     uintptr_t size,
-                                     uintptr_t redzone_size,
+void PoisonShadowPartialRightRedzone(uptr addr,
+                                     uptr size,
+                                     uptr redzone_size,
                                      uint8_t value);
 
 // Platfrom-specific options.
@@ -241,21 +240,21 @@ bool PlatformHasDifferentMemcpyAndMemmove();
 # define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE true
 #endif  // __APPLE__
 
-extern size_t  FLAG_quarantine_size;
+extern uptr  FLAG_quarantine_size;
 extern int64_t FLAG_demangle;
 extern bool    FLAG_symbolize;
 extern int64_t FLAG_v;
-extern size_t  FLAG_redzone;
+extern uptr  FLAG_redzone;
 extern int64_t FLAG_debug;
 extern bool    FLAG_poison_shadow;
 extern int64_t FLAG_report_globals;
-extern size_t  FLAG_malloc_context_size;
+extern uptr  FLAG_malloc_context_size;
 extern bool    FLAG_replace_str;
 extern bool    FLAG_replace_intrin;
 extern bool    FLAG_replace_cfallocator;
 extern bool    FLAG_fast_unwind;
 extern bool    FLAG_use_fake_stack;
-extern size_t  FLAG_max_malloc_fill_size;
+extern uptr  FLAG_max_malloc_fill_size;
 extern int64_t FLAG_exitcode;
 extern bool    FLAG_allow_user_poisoning;
 extern int64_t FLAG_sleep_before_dying;
@@ -292,28 +291,28 @@ int Atexit(void (*function)(void));
 
 #define ASAN_ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
 
-const size_t kWordSize = __WORDSIZE / 8;
-const size_t kWordSizeInBits = 8 * kWordSize;
-const size_t kPageSizeBits = 12;
-const size_t kPageSize = 1UL << kPageSizeBits;
+const uptr kWordSize = __WORDSIZE / 8;
+const uptr kWordSizeInBits = 8 * kWordSize;
+const uptr kPageSizeBits = 12;
+const uptr kPageSize = 1UL << kPageSizeBits;
 
 #if !defined(_WIN32) || defined(__clang__)
-# define GET_CALLER_PC() (uintptr_t)__builtin_return_address(0)
-# define GET_CURRENT_FRAME() (uintptr_t)__builtin_frame_address(0)
+# define GET_CALLER_PC() (uptr)__builtin_return_address(0)
+# define GET_CURRENT_FRAME() (uptr)__builtin_frame_address(0)
 #else
-# define GET_CALLER_PC() (uintptr_t)_ReturnAddress()
+# define GET_CALLER_PC() (uptr)_ReturnAddress()
 // CaptureStackBackTrace doesn't need to know BP on Windows.
 // FIXME: This macro is still used when printing error reports though it's not
 // clear if the BP value is needed in the ASan reports on Windows.
-# define GET_CURRENT_FRAME() (uintptr_t)0xDEADBEEF
+# define GET_CURRENT_FRAME() (uptr)0xDEADBEEF
 #endif
 
 #ifndef _WIN32
-const size_t kMmapGranularity = kPageSize;
+const uptr kMmapGranularity = kPageSize;
 # define THREAD_CALLING_CONV
 typedef void* thread_return_t;
 #else
-const size_t kMmapGranularity = 1UL << 16;
+const uptr kMmapGranularity = 1UL << 16;
 # define THREAD_CALLING_CONV __stdcall
 typedef DWORD thread_return_t;
 
@@ -338,15 +337,15 @@ const int kAsanUserPoisonedMemoryMagic = 0xf7;
 const int kAsanGlobalRedzoneMagic = 0xf9;
 const int kAsanInternalHeapMagic = 0xfe;
 
-static const uintptr_t kCurrentStackFrameMagic = 0x41B58AB3;
-static const uintptr_t kRetiredStackFrameMagic = 0x45E0360E;
+static const uptr kCurrentStackFrameMagic = 0x41B58AB3;
+static const uptr kRetiredStackFrameMagic = 0x45E0360E;
 
 // --------------------------- Bit twiddling ------- {{{1
-inline bool IsPowerOfTwo(size_t x) {
+inline bool IsPowerOfTwo(uptr x) {
   return (x & (x - 1)) == 0;
 }
 
-inline size_t RoundUpTo(size_t size, size_t boundary) {
+inline uptr RoundUpTo(uptr size, uptr boundary) {
   CHECK(IsPowerOfTwo(boundary));
   return (size + boundary - 1) & ~(boundary - 1);
 }
@@ -358,7 +357,7 @@ class LowLevelAllocator {
   explicit LowLevelAllocator(LinkerInitialized) {}
   // 'size' must be a power of two.
   // Requires an external lock.
-  void *Allocate(size_t size);
+  void *Allocate(uptr size);
  private:
   char *allocated_end_;
   char *allocated_current_;
diff --git a/compiler-rt/lib/asan/asan_linux.cc b/compiler-rt/lib/asan/asan_linux.cc
index 26c67e91747..5ff4dea64c1 100644
--- a/compiler-rt/lib/asan/asan_linux.cc
+++ b/compiler-rt/lib/asan/asan_linux.cc
@@ -39,14 +39,14 @@ extern "C" void* _DYNAMIC;
 
 namespace __asan {
 
-const size_t kMaxThreadStackSize = 256 * (1 << 20);  // 256M
+const uptr kMaxThreadStackSize = 256 * (1 << 20);  // 256M
 
 void *AsanDoesNotSupportStaticLinkage() {
   // This will fail to link with -static.
   return &_DYNAMIC;  // defined in link.h
 }
 
-void GetPcSpBp(void *context, uintptr_t *pc, uintptr_t *sp, uintptr_t *bp) {
+void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
 #ifdef ANDROID
   *pc = *sp = *bp = 0;
 #elif defined(__arm__)
@@ -73,7 +73,7 @@ bool AsanInterceptsSignal(int signum) {
   return signum == SIGSEGV && FLAG_handle_segv;
 }
 
-static void *asan_mmap(void *addr, size_t length, int prot, int flags,
+static void *asan_mmap(void *addr, uptr length, int prot, int flags,
                 int fd, uint64_t offset) {
 # if __WORDSIZE == 64
   return (void *)syscall(__NR_mmap, addr, length, prot, flags, fd, offset);
@@ -82,7 +82,7 @@ static void *asan_mmap(void *addr, size_t length, int prot, int flags,
 # endif
 }
 
-void *AsanMmapSomewhereOrDie(size_t size, const char *mem_type) {
+void *AsanMmapSomewhereOrDie(uptr size, const char *mem_type) {
   size = RoundUpTo(size, kPageSize);
   void *res = asan_mmap(0, size,
                         PROT_READ | PROT_WRITE,
@@ -93,21 +93,21 @@ void *AsanMmapSomewhereOrDie(size_t size, const char *mem_type) {
   return res;
 }
 
-void *AsanMmapFixedNoReserve(uintptr_t fixed_addr, size_t size) {
+void *AsanMmapFixedNoReserve(uptr fixed_addr, uptr size) {
   return asan_mmap((void*)fixed_addr, size,
                    PROT_READ | PROT_WRITE,
                    MAP_PRIVATE | MAP_ANON | MAP_FIXED | MAP_NORESERVE,
                    0, 0);
 }
 
-void *AsanMprotect(uintptr_t fixed_addr, size_t size) {
+void *AsanMprotect(uptr fixed_addr, uptr size) {
   return asan_mmap((void*)fixed_addr, size,
                    PROT_NONE,
                    MAP_PRIVATE | MAP_ANON | MAP_FIXED | MAP_NORESERVE,
                    0, 0);
 }
 
-void AsanUnmapOrDie(void *addr, size_t size) {
+void AsanUnmapOrDie(void *addr, uptr size) {
   if (!addr || !size) return;
   int res = syscall(__NR_munmap, addr, size);
   if (res != 0) {
@@ -116,8 +116,8 @@ void AsanUnmapOrDie(void *addr, size_t size) {
   }
 }
 
-size_t AsanWrite(int fd, const void *buf, size_t count) {
-  return (size_t)syscall(__NR_write, fd, buf, count);
+uptr AsanWrite(int fd, const void *buf, uptr count) {
+  return (uptr)syscall(__NR_write, fd, buf, count);
 }
 
 int AsanOpenReadonly(const char* filename) {
@@ -128,32 +128,32 @@ int AsanOpenReadonly(const char* filename) {
 // This function should be called first inside __asan_init.
 const char* AsanGetEnv(const char* name) {
   static char *environ;
-  static size_t len;
+  static uptr len;
   static bool inited;
   if (!inited) {
     inited = true;
-    size_t environ_size;
+    uptr environ_size;
     len = ReadFileToBuffer("/proc/self/environ",
                            &environ, &environ_size, 1 << 26);
   }
-  if (!environ || len == 0) return NULL;
-  size_t namelen = internal_strlen(name);
+  if (!environ || len == 0) return 0;
+  uptr namelen = internal_strlen(name);
   const char *p = environ;
   while (*p != '\0') {  // will happen at the \0\0 that terminates the buffer
     // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
     const char* endp =
         (char*)internal_memchr(p, '\0', len - (p - environ));
-    if (endp == NULL)  // this entry isn't NUL terminated
-      return NULL;
+    if (endp == 0)  // this entry isn't NUL terminated
+      return 0;
     else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=')  // Match.
       return p + namelen + 1;  // point after =
     p = endp + 1;
   }
-  return NULL;  // Not found.
+  return 0;  // Not found.
 }
 
-size_t AsanRead(int fd, void *buf, size_t count) {
-  return (size_t)syscall(__NR_read, fd, buf, count);
+uptr AsanRead(int fd, void *buf, uptr count) {
+  return (uptr)syscall(__NR_read, fd, buf, count);
 }
 
 int AsanClose(int fd) {
@@ -177,21 +177,21 @@ void AsanProcMaps::Reset() {
   current_ = proc_self_maps_buff_;
 }
 
-bool AsanProcMaps::Next(uintptr_t *start, uintptr_t *end,
-                        uintptr_t *offset, char filename[],
-                        size_t filename_size) {
+bool AsanProcMaps::Next(uptr *start, uptr *end,
+                        uptr *offset, char filename[],
+                        uptr filename_size) {
   char *last = proc_self_maps_buff_ + proc_self_maps_buff_len_;
   if (current_ >= last) return false;
   int consumed = 0;
   char flags[10];
   int major, minor;
-  uintptr_t inode;
-  uintptr_t dummy;
+  uptr inode;
+  uptr dummy;
   if (!start) start = &dummy;
   if (!end) end = &dummy;
   if (!offset) offset = &dummy;
   char *next_line = (char*)internal_memchr(current_, '\n', last - current_);
-  if (next_line == NULL)
+  if (next_line == 0)
     next_line = last;
   if (SScanf(current_,
              "%lx-%lx %4s %lx %x:%x %ld %n",
@@ -203,7 +203,7 @@ bool AsanProcMaps::Next(uintptr_t *start, uintptr_t *end,
   while (current_ < next_line && *current_ == ' ')
     current_++;
   // Fill in the filename.
-  size_t i = 0;
+  uptr i = 0;
   while (current_ < next_line) {
     if (filename && i < filename_size - 1)
       filename[i++] = *current_;
@@ -216,9 +216,9 @@ bool AsanProcMaps::Next(uintptr_t *start, uintptr_t *end,
 }
 
 // Gets the object name and the offset by walking AsanProcMaps.
-bool AsanProcMaps::GetObjectNameAndOffset(uintptr_t addr, uintptr_t *offset,
+bool AsanProcMaps::GetObjectNameAndOffset(uptr addr, uptr *offset,
                                           char filename[],
-                                          size_t filename_size) {
+                                          uptr filename_size) {
   return IterateForObjectNameAndOffset(addr, offset, filename, filename_size);
 }
 
@@ -230,18 +230,18 @@ void AsanThread::SetThreadStackTopAndBottom() {
 
     // Find the mapping that contains a stack variable.
     AsanProcMaps proc_maps;
-    uintptr_t start, end, offset;
-    uintptr_t prev_end = 0;
-    while (proc_maps.Next(&start, &end, &offset, NULL, 0)) {
-      if ((uintptr_t)&rl < end)
+    uptr start, end, offset;
+    uptr prev_end = 0;
+    while (proc_maps.Next(&start, &end, &offset, 0, 0)) {
+      if ((uptr)&rl < end)
         break;
       prev_end = end;
     }
-    CHECK((uintptr_t)&rl >= start && (uintptr_t)&rl < end);
+    CHECK((uptr)&rl >= start && (uptr)&rl < end);
 
     // Get stacksize from rlimit, but clip it so that it does not overlap
     // with other mappings.
-    size_t stacksize = rl.rlim_cur;
+    uptr stacksize = rl.rlim_cur;
     if (stacksize > end - prev_end)
       stacksize = end - prev_end;
     // When running with unlimited stack size, we still want to set some limit.
@@ -251,20 +251,20 @@ void AsanThread::SetThreadStackTopAndBottom() {
       stacksize = kMaxThreadStackSize;
     stack_top_ = end;
     stack_bottom_ = end - stacksize;
-    CHECK(AddrIsInStack((uintptr_t)&rl));
+    CHECK(AddrIsInStack((uptr)&rl));
     return;
   }
   pthread_attr_t attr;
   CHECK(pthread_getattr_np(pthread_self(), &attr) == 0);
-  size_t stacksize = 0;
-  void *stackaddr = NULL;
-  pthread_attr_getstack(&attr, &stackaddr, &stacksize);
+  uptr stacksize = 0;
+  void *stackaddr = 0;
+  pthread_attr_getstack(&attr, &stackaddr, (size_t*)&stacksize);
   pthread_attr_destroy(&attr);
 
-  stack_top_ = (uintptr_t)stackaddr + stacksize;
-  stack_bottom_ = (uintptr_t)stackaddr;
+  stack_top_ = (uptr)stackaddr + stacksize;
+  stack_bottom_ = (uptr)stackaddr;
   CHECK(stacksize < kMaxThreadStackSize);  // Sanity check.
-  CHECK(AddrIsInStack((uintptr_t)&attr));
+  CHECK(AddrIsInStack((uptr)&attr));
 }
 
 AsanLock::AsanLock(LinkerInitialized) {
@@ -278,11 +278,11 @@ void AsanLock::Lock() {
   CHECK(sizeof(pthread_mutex_t) <= sizeof(opaque_storage_));
   pthread_mutex_lock((pthread_mutex_t*)&opaque_storage_);
   CHECK(!owner_);
-  owner_ = (uintptr_t)pthread_self();
+  owner_ = (uptr)pthread_self();
 }
 
 void AsanLock::Unlock() {
-  CHECK(owner_ == (uintptr_t)pthread_self());
+  CHECK(owner_ == (uptr)pthread_self());
   owner_ = 0;
   pthread_mutex_unlock((pthread_mutex_t*)&opaque_storage_);
 }
@@ -295,14 +295,14 @@ void AsanLock::Unlock() {
 #define UNWIND_CONTINUE _URC_NO_REASON
 #endif
 
-uintptr_t Unwind_GetIP(struct _Unwind_Context *ctx) {
+uptr Unwind_GetIP(struct _Unwind_Context *ctx) {
 #ifdef __arm__
-  uintptr_t val;
+  uptr val;
   _Unwind_VRS_Result res = _Unwind_VRS_Get(ctx, _UVRSC_CORE,
       15 /* r15 = PC */, _UVRSD_UINT32, &val);
   CHECK(res == _UVRSR_OK && "_Unwind_VRS_Get failed");
   // Clear the Thumb bit.
-  return val & ~(uintptr_t)1;
+  return val & ~(uptr)1;
 #else
   return _Unwind_GetIP(ctx);
 #endif
@@ -312,13 +312,13 @@ _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx,
     void *param) {
   AsanStackTrace *b = (AsanStackTrace*)param;
   CHECK(b->size < b->max_size);
-  uintptr_t pc = Unwind_GetIP(ctx);
+  uptr pc = Unwind_GetIP(ctx);
   b->trace[b->size++] = pc;
   if (b->size == b->max_size) return UNWIND_STOP;
   return UNWIND_CONTINUE;
 }
 
-void AsanStackTrace::GetStackTrace(size_t max_s, uintptr_t pc, uintptr_t bp) {
+void AsanStackTrace::GetStackTrace(uptr max_s, uptr pc, uptr bp) {
   size = 0;
   trace[0] = pc;
   if ((max_s) > 1) {
diff --git a/compiler-rt/lib/asan/asan_lock.h b/compiler-rt/lib/asan/asan_lock.h
index 75da8ae68cb..15b2180ce84 100644
--- a/compiler-rt/lib/asan/asan_lock.h
+++ b/compiler-rt/lib/asan/asan_lock.h
@@ -30,8 +30,8 @@ class AsanLock {
   void Unlock();
   bool IsLocked() { return owner_ != 0; }
  private:
-  uintptr_t opaque_storage_[10];
-  uintptr_t owner_;  // for debugging and for malloc_introspection_t interface
+  uptr opaque_storage_[10];
+  uptr owner_;  // for debugging and for malloc_introspection_t interface
 };
 
 class ScopedLock {
diff --git a/compiler-rt/lib/asan/asan_mac.cc b/compiler-rt/lib/asan/asan_mac.cc
index df039c55c03..e3c1e722ab7 100644
--- a/compiler-rt/lib/asan/asan_mac.cc
+++ b/compiler-rt/lib/asan/asan_mac.cc
@@ -37,7 +37,7 @@
 
 namespace __asan {
 
-void GetPcSpBp(void *context, uintptr_t *pc, uintptr_t *sp, uintptr_t *bp) {
+void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
   ucontext_t *ucontext = (ucontext_t*)context;
 # if __WORDSIZE == 64
   *pc = ucontext->uc_mcontext->__ss.__rip;
@@ -63,9 +63,9 @@ static int GetMacosVersion() {
   size_t len = 0, maxlen = sizeof(version) / sizeof(version[0]);
   for (int i = 0; i < maxlen; i++) version[i] = '\0';
   // Get the version length.
-  CHECK(sysctl(mib, 2, NULL, &len, NULL, 0) != -1);
+  CHECK(sysctl(mib, 2, 0, &len, 0, 0) != -1);
   CHECK(len < maxlen);
-  CHECK(sysctl(mib, 2, version, &len, NULL, 0) != -1);
+  CHECK(sysctl(mib, 2, version, &len, 0, 0) != -1);
   switch (version[0]) {
     case '9': return MACOS_VERSION_LEOPARD;
     case '1': {
@@ -90,7 +90,7 @@ bool PlatformHasDifferentMemcpyAndMemmove() {
 
 // No-op. Mac does not support static linkage anyway.
 void *AsanDoesNotSupportStaticLinkage() {
-  return NULL;
+  return 0;
 }
 
 bool AsanInterceptsSignal(int signum) {
@@ -117,14 +117,14 @@ void *AsanMmapSomewhereOrDie(size_t size, const char *mem_type) {
   return res;
 }
 
-void *AsanMmapFixedNoReserve(uintptr_t fixed_addr, size_t size) {
+void *AsanMmapFixedNoReserve(uptr fixed_addr, size_t size) {
   return asan_mmap((void*)fixed_addr, size,
                    PROT_READ | PROT_WRITE,
                    MAP_PRIVATE | MAP_ANON | MAP_FIXED | MAP_NORESERVE,
                    0, 0);
 }
 
-void *AsanMprotect(uintptr_t fixed_addr, size_t size) {
+void *AsanMprotect(uptr fixed_addr, size_t size) {
   return asan_mmap((void*)fixed_addr, size,
                    PROT_NONE,
                    MAP_PRIVATE | MAP_ANON | MAP_FIXED | MAP_NORESERVE,
@@ -150,7 +150,7 @@ const char *AsanGetEnv(const char *name) {
   char **environ = *env_ptr;
   CHECK(environ);
   size_t name_len = internal_strlen(name);
-  while (*environ != NULL) {
+  while (*environ != 0) {
     size_t len = internal_strlen(*environ);
     if (len > name_len) {
       const char *p = *environ;
@@ -161,7 +161,7 @@ const char *AsanGetEnv(const char *name) {
     }
     environ++;
   }
-  return NULL;
+  return 0;
 }
 
 size_t AsanRead(int fd, void *buf, size_t count) {
@@ -200,7 +200,7 @@ void AsanProcMaps::Reset() {
   // adding and removing images which will invalidate the AsanProcMaps state.
   current_image_ = _dyld_image_count();
   current_load_cmd_count_ = -1;
-  current_load_cmd_addr_ = NULL;
+  current_load_cmd_addr_ = 0;
   current_magic_ = 0;
 }
 
@@ -213,7 +213,7 @@ void AsanProcMaps::Reset() {
 // Note that the segment addresses are not necessarily sorted.
 template<uint32_t kLCSegment, typename SegmentCommand>
 bool AsanProcMaps::NextSegmentLoad(
-    uintptr_t *start, uintptr_t *end, uintptr_t *offset,
+    uptr *start, uptr *end, uptr *offset,
     char filename[], size_t filename_size) {
   const char* lc = current_load_cmd_addr_;
   current_load_cmd_addr_ += ((const load_command *)lc)->cmdsize;
@@ -234,8 +234,8 @@ bool AsanProcMaps::NextSegmentLoad(
   return false;
 }
 
-bool AsanProcMaps::Next(uintptr_t *start, uintptr_t *end,
-                        uintptr_t *offset, char filename[],
+bool AsanProcMaps::Next(uptr *start, uptr *end,
+                        uptr *offset, char filename[],
                         size_t filename_size) {
   for (; current_image_ >= 0; current_image_--) {
     const mach_header* hdr = _dyld_get_image_header(current_image_);
@@ -286,7 +286,7 @@ bool AsanProcMaps::Next(uintptr_t *start, uintptr_t *end,
   return false;
 }
 
-bool AsanProcMaps::GetObjectNameAndOffset(uintptr_t addr, uintptr_t *offset,
+bool AsanProcMaps::GetObjectNameAndOffset(uptr addr, uptr *offset,
                                           char filename[],
                                           size_t filename_size) {
   return IterateForObjectNameAndOffset(addr, offset, filename, filename_size);
@@ -295,10 +295,10 @@ bool AsanProcMaps::GetObjectNameAndOffset(uintptr_t addr, uintptr_t *offset,
 void AsanThread::SetThreadStackTopAndBottom() {
   size_t stacksize = pthread_get_stacksize_np(pthread_self());
   void *stackaddr = pthread_get_stackaddr_np(pthread_self());
-  stack_top_ = (uintptr_t)stackaddr;
+  stack_top_ = (uptr)stackaddr;
   stack_bottom_ = stack_top_ - stacksize;
   int local;
-  CHECK(AddrIsInStack((uintptr_t)&local));
+  CHECK(AddrIsInStack((uptr)&local));
 }
 
 AsanLock::AsanLock(LinkerInitialized) {
@@ -308,19 +308,19 @@ AsanLock::AsanLock(LinkerInitialized) {
 void AsanLock::Lock() {
   CHECK(sizeof(OSSpinLock) <= sizeof(opaque_storage_));
   CHECK(OS_SPINLOCK_INIT == 0);
-  CHECK(owner_ != (uintptr_t)pthread_self());
+  CHECK(owner_ != (uptr)pthread_self());
   OSSpinLockLock((OSSpinLock*)&opaque_storage_);
   CHECK(!owner_);
-  owner_ = (uintptr_t)pthread_self();
+  owner_ = (uptr)pthread_self();
 }
 
 void AsanLock::Unlock() {
-  CHECK(owner_ == (uintptr_t)pthread_self());
+  CHECK(owner_ == (uptr)pthread_self());
   owner_ = 0;
   OSSpinLockUnlock((OSSpinLock*)&opaque_storage_);
 }
 
-void AsanStackTrace::GetStackTrace(size_t max_s, uintptr_t pc, uintptr_t bp) {
+void AsanStackTrace::GetStackTrace(size_t max_s, uptr pc, uptr bp) {
   size = 0;
   trace[0] = pc;
   if ((max_s) > 1) {
@@ -335,7 +335,7 @@ void AsanStackTrace::GetStackTrace(size_t max_s, uintptr_t pc, uintptr_t bp) {
 // These constants were chosen empirically and may not work if the shadow
 // memory layout changes. Unfortunately they do necessarily depend on
 // kHighMemBeg or kHighMemEnd.
-static void *island_allocator_pos = NULL;
+static void *island_allocator_pos = 0;
 
 #if __WORDSIZE == 32
 # define kIslandEnd (0xffdf0000 - kPageSize)
@@ -457,7 +457,7 @@ void asan_dispatch_call_block_and_release(void *block) {
   }
   AsanThread *t = asanThreadRegistry().GetCurrent();
   if (!t) {
-    t = AsanThread::Create(context->parent_tid, NULL, NULL, &stack);
+    t = AsanThread::Create(context->parent_tid, 0, 0, &stack);
     asanThreadRegistry().RegisterThread(t);
     t->Init();
     asanThreadRegistry().SetCurrent(t);
@@ -603,7 +603,7 @@ INTERCEPTOR(int, pthread_workqueue_additem_np, pthread_workqueue_t workq,
 
 // See http://opensource.apple.com/source/CF/CF-635.15/CFRuntime.h
 typedef struct __CFRuntimeBase {
-  uintptr_t _cfisa;
+  uptr _cfisa;
   uint8_t _cfinfo[4];
 #if __LP64__
   uint32_t _rc;
diff --git a/compiler-rt/lib/asan/asan_malloc_linux.cc b/compiler-rt/lib/asan/asan_malloc_linux.cc
index 84ef929cd7c..c676d9b12a3 100644
--- a/compiler-rt/lib/asan/asan_malloc_linux.cc
+++ b/compiler-rt/lib/asan/asan_malloc_linux.cc
@@ -73,7 +73,7 @@ INTERCEPTOR(void*, calloc, size_t nmemb, size_t size) {
   if (!asan_inited) {
     // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
     const size_t kCallocPoolSize = 1024;
-    static uintptr_t calloc_memory_for_dlsym[kCallocPoolSize];
+    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
     static size_t allocated;
     size_t size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
     void *mem = (void*)&calloc_memory_for_dlsym[allocated];
diff --git a/compiler-rt/lib/asan/asan_malloc_mac.cc b/compiler-rt/lib/asan/asan_malloc_mac.cc
index 14d63858a4a..7dcc41c4443 100644
--- a/compiler-rt/lib/asan/asan_malloc_mac.cc
+++ b/compiler-rt/lib/asan/asan_malloc_mac.cc
@@ -31,7 +31,7 @@
 using namespace __asan;  // NOLINT
 
 // The free() implementation provided by OS X calls malloc_zone_from_ptr()
-// to find the owner of |ptr|. If the result is NULL, an invalid free() is
+// to find the owner of |ptr|. If the result is 0, an invalid free() is
 // reported. Our implementation falls back to asan_free() in this case
 // in order to print an ASan-style report.
 extern "C"
@@ -55,8 +55,8 @@ void free(void *ptr) {
 }
 
 // TODO(glider): do we need both zones?
-static malloc_zone_t *system_malloc_zone = NULL;
-static malloc_zone_t *system_purgeable_zone = NULL;
+static malloc_zone_t *system_malloc_zone = 0;
+static malloc_zone_t *system_purgeable_zone = 0;
 
 // We need to provide wrappers around all the libc functions.
 namespace {
@@ -94,7 +94,7 @@ void *mz_calloc(malloc_zone_t *zone, size_t nmemb, size_t size) {
   if (!asan_inited) {
     // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
     const size_t kCallocPoolSize = 1024;
-    static uintptr_t calloc_memory_for_dlsym[kCallocPoolSize];
+    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
     static size_t allocated;
     size_t size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
     void *mem = (void*)&calloc_memory_for_dlsym[allocated];
@@ -126,7 +126,7 @@ void print_zone_for_ptr(void *ptr) {
              ptr, orig_zone);
     }
   } else {
-    Printf("malloc_zone_from_ptr(%p) = NULL\n", ptr);
+    Printf("malloc_zone_from_ptr(%p) = 0\n", ptr);
   }
 }
 
@@ -197,7 +197,7 @@ void *mz_realloc(malloc_zone_t *zone, void *ptr, size_t size) {
       GET_STACK_TRACE_HERE_FOR_FREE(ptr);
       stack.PrintStack();
       ShowStatsAndAbort();
-      return NULL;  // unreachable
+      return 0;  // unreachable
     }
   }
 }
@@ -220,7 +220,7 @@ void *cf_realloc(void *ptr, CFIndex size, CFOptionFlags hint, void *info) {
       GET_STACK_TRACE_HERE_FOR_FREE(ptr);
       stack.PrintStack();
       ShowStatsAndAbort();
-      return NULL;  // unreachable
+      return 0;  // unreachable
     }
   }
 }
@@ -337,8 +337,8 @@ void ReplaceSystemMalloc() {
   asan_zone.free = &mz_free;
   asan_zone.realloc = &mz_realloc;
   asan_zone.destroy = &mz_destroy;
-  asan_zone.batch_malloc = NULL;
-  asan_zone.batch_free = NULL;
+  asan_zone.batch_malloc = 0;
+  asan_zone.batch_free = 0;
   asan_zone.introspect = &asan_introspection;
 
   // from AvailabilityMacros.h
@@ -378,12 +378,12 @@ void ReplaceSystemMalloc() {
   if (FLAG_replace_cfallocator) {
     static CFAllocatorContext asan_context =
         { /*version*/ 0, /*info*/ &asan_zone,
-          /*retain*/ NULL, /*release*/ NULL,
-          /*copyDescription*/NULL,
+          /*retain*/ 0, /*release*/ 0,
+          /*copyDescription*/0,
           /*allocate*/ &cf_malloc,
           /*reallocate*/ &cf_realloc,
           /*deallocate*/ &cf_free,
-          /*preferredSize*/ NULL };
+          /*preferredSize*/ 0 };
     CFAllocatorRef cf_asan =
         CFAllocatorCreate(kCFAllocatorUseContext, &asan_context);
     CFAllocatorSetDefault(cf_asan);
diff --git a/compiler-rt/lib/asan/asan_malloc_win.cc b/compiler-rt/lib/asan/asan_malloc_win.cc
index 42ba8fe08e4..ae0bfabeb91 100644
--- a/compiler-rt/lib/asan/asan_malloc_win.cc
+++ b/compiler-rt/lib/asan/asan_malloc_win.cc
@@ -71,7 +71,7 @@ void *realloc(void *ptr, size_t size) {
 
 void *_realloc_dbg(void *ptr, size_t size, int) {
   CHECK(!"_realloc_dbg should not exist!");
-  return NULL;
+  return 0;
 }
 
 void* _recalloc(void* p, size_t n, size_t elem_size) {
@@ -79,7 +79,7 @@ void* _recalloc(void* p, size_t n, size_t elem_size) {
     return calloc(n, elem_size);
   const size_t size = n * elem_size;
   if (elem_size != 0 && size / elem_size != n)
-    return NULL;
+    return 0;
   return realloc(p, size);
 }
 
diff --git a/compiler-rt/lib/asan/asan_mapping.h b/compiler-rt/lib/asan/asan_mapping.h
index 22ee81fb5c4..31564f71b60 100644
--- a/compiler-rt/lib/asan/asan_mapping.h
+++ b/compiler-rt/lib/asan/asan_mapping.h
@@ -20,8 +20,8 @@
 // http://code.google.com/p/address-sanitizer/wiki/AddressSanitizerAlgorithm
 
 #if ASAN_FLEXIBLE_MAPPING_AND_OFFSET == 1
-extern __attribute__((visibility("default"))) uintptr_t __asan_mapping_scale;
-extern __attribute__((visibility("default"))) uintptr_t __asan_mapping_offset;
+extern __attribute__((visibility("default"))) uptr __asan_mapping_scale;
+extern __attribute__((visibility("default"))) uptr __asan_mapping_offset;
 # define SHADOW_SCALE (__asan_mapping_scale)
 # define SHADOW_OFFSET (__asan_mapping_offset)
 #else
@@ -43,9 +43,9 @@ extern __attribute__((visibility("default"))) uintptr_t __asan_mapping_offset;
 #define SHADOW_TO_MEM(shadow) (((shadow) - SHADOW_OFFSET) << SHADOW_SCALE)
 
 #if __WORDSIZE == 64
-  static const size_t kHighMemEnd = 0x00007fffffffffffUL;
+  static const uptr kHighMemEnd = 0x00007fffffffffffUL;
 #else  // __WORDSIZE == 32
-  static const size_t kHighMemEnd = 0xffffffff;
+  static const uptr kHighMemEnd = 0xffffffff;
 #endif  // __WORDSIZE
 
 
@@ -68,41 +68,41 @@ extern __attribute__((visibility("default"))) uintptr_t __asan_mapping_offset;
 
 namespace __asan {
 
-static inline bool AddrIsInLowMem(uintptr_t a) {
+static inline bool AddrIsInLowMem(uptr a) {
   return a < kLowMemEnd;
 }
 
-static inline bool AddrIsInLowShadow(uintptr_t a) {
+static inline bool AddrIsInLowShadow(uptr a) {
   return a >= kLowShadowBeg && a <= kLowShadowEnd;
 }
 
-static inline bool AddrIsInHighMem(uintptr_t a) {
+static inline bool AddrIsInHighMem(uptr a) {
   return a >= kHighMemBeg && a <= kHighMemEnd;
 }
 
-static inline bool AddrIsInMem(uintptr_t a) {
+static inline bool AddrIsInMem(uptr a) {
   return AddrIsInLowMem(a) || AddrIsInHighMem(a);
 }
 
-static inline uintptr_t MemToShadow(uintptr_t p) {
+static inline uptr MemToShadow(uptr p) {
   CHECK(AddrIsInMem(p));
   return MEM_TO_SHADOW(p);
 }
 
-static inline bool AddrIsInHighShadow(uintptr_t a) {
+static inline bool AddrIsInHighShadow(uptr a) {
   return a >= kHighShadowBeg && a <=  kHighMemEnd;
 }
 
-static inline bool AddrIsInShadow(uintptr_t a) {
+static inline bool AddrIsInShadow(uptr a) {
   return AddrIsInLowShadow(a) || AddrIsInHighShadow(a);
 }
 
-static inline bool AddrIsAlignedByGranularity(uintptr_t a) {
+static inline bool AddrIsAlignedByGranularity(uptr a) {
   return (a & (SHADOW_GRANULARITY - 1)) == 0;
 }
 
-static inline bool AddressIsPoisoned(uintptr_t a) {
-  const size_t kAccessSize = 1;
+static inline bool AddressIsPoisoned(uptr a) {
+  const uptr kAccessSize = 1;
   uint8_t *shadow_address = (uint8_t*)MemToShadow(a);
   int8_t shadow_value = *shadow_address;
   if (shadow_value) {
diff --git a/compiler-rt/lib/asan/asan_poisoning.cc b/compiler-rt/lib/asan/asan_poisoning.cc
index 82d4a5cacaf..36b14e8f8c9 100644
--- a/compiler-rt/lib/asan/asan_poisoning.cc
+++ b/compiler-rt/lib/asan/asan_poisoning.cc
@@ -19,22 +19,22 @@
 
 namespace __asan {
 
-void PoisonShadow(uintptr_t addr, size_t size, uint8_t value) {
+void PoisonShadow(uptr addr, uptr size, uint8_t value) {
   CHECK(AddrIsAlignedByGranularity(addr));
   CHECK(AddrIsAlignedByGranularity(addr + size));
-  uintptr_t shadow_beg = MemToShadow(addr);
-  uintptr_t shadow_end = MemToShadow(addr + size);
-  CHECK(REAL(memset) != NULL);
+  uptr shadow_beg = MemToShadow(addr);
+  uptr shadow_end = MemToShadow(addr + size);
+  CHECK(REAL(memset) != 0);
   REAL(memset)((void*)shadow_beg, value, shadow_end - shadow_beg);
 }
 
-void PoisonShadowPartialRightRedzone(uintptr_t addr,
-                                     uintptr_t size,
-                                     uintptr_t redzone_size,
+void PoisonShadowPartialRightRedzone(uptr addr,
+                                     uptr size,
+                                     uptr redzone_size,
                                      uint8_t value) {
   CHECK(AddrIsAlignedByGranularity(addr));
   uint8_t *shadow = (uint8_t*)MemToShadow(addr);
-  for (uintptr_t i = 0; i < redzone_size;
+  for (uptr i = 0; i < redzone_size;
        i += SHADOW_GRANULARITY, shadow++) {
     if (i + SHADOW_GRANULARITY <= size) {
       *shadow = 0;  // fully addressable
@@ -52,7 +52,7 @@ struct ShadowSegmentEndpoint {
   int8_t offset;  // in [0, SHADOW_GRANULARITY)
   int8_t value;  // = *chunk;
 
-  explicit ShadowSegmentEndpoint(uintptr_t address) {
+  explicit ShadowSegmentEndpoint(uptr address) {
     chunk = (uint8_t*)MemToShadow(address);
     offset = address & (SHADOW_GRANULARITY - 1);
     value = *chunk;
@@ -76,8 +76,8 @@ using namespace __asan;  // NOLINT
 // at most [AlignDown(left), right).
 void __asan_poison_memory_region(void const volatile *addr, uptr size) {
   if (!FLAG_allow_user_poisoning || size == 0) return;
-  uintptr_t beg_addr = (uintptr_t)addr;
-  uintptr_t end_addr = beg_addr + size;
+  uptr beg_addr = (uptr)addr;
+  uptr end_addr = beg_addr + size;
   if (FLAG_v >= 1) {
     Printf("Trying to poison memory region [%p, %p)\n", beg_addr, end_addr);
   }
@@ -117,8 +117,8 @@ void __asan_poison_memory_region(void const volatile *addr, uptr size) {
 
 void __asan_unpoison_memory_region(void const volatile *addr, uptr size) {
   if (!FLAG_allow_user_poisoning || size == 0) return;
-  uintptr_t beg_addr = (uintptr_t)addr;
-  uintptr_t end_addr = beg_addr + size;
+  uptr beg_addr = (uptr)addr;
+  uptr end_addr = beg_addr + size;
   if (FLAG_v >= 1) {
     Printf("Trying to unpoison memory region [%p, %p)\n", beg_addr, end_addr);
   }
@@ -147,5 +147,5 @@ void __asan_unpoison_memory_region(void const volatile *addr, uptr size) {
 }
 
 bool __asan_address_is_poisoned(void const volatile *addr) {
-  return __asan::AddressIsPoisoned((uintptr_t)addr);
+  return __asan::AddressIsPoisoned((uptr)addr);
 }
diff --git a/compiler-rt/lib/asan/asan_posix.cc b/compiler-rt/lib/asan/asan_posix.cc
index 7ce296e8083..9fde9df4c3b 100644
--- a/compiler-rt/lib/asan/asan_posix.cc
+++ b/compiler-rt/lib/asan/asan_posix.cc
@@ -35,12 +35,12 @@
 // since most of the stuff here is inlinable.
 #include <algorithm>
 
-static const size_t kAltStackSize = SIGSTKSZ * 4;  // SIGSTKSZ is not enough.
+static const uptr kAltStackSize = SIGSTKSZ * 4;  // SIGSTKSZ is not enough.
 
 namespace __asan {
 
-static inline bool IntervalsAreSeparate(uintptr_t start1, uintptr_t end1,
-                                        uintptr_t start2, uintptr_t end2) {
+static inline bool IntervalsAreSeparate(uptr start1, uptr end1,
+                                        uptr start2, uptr end2) {
   CHECK(start1 <= end1);
   CHECK(start2 <= end2);
   return (end1 < start2) || (end2 < start1);
@@ -52,12 +52,12 @@ static inline bool IntervalsAreSeparate(uintptr_t start1, uintptr_t end1,
 // memory).
 bool AsanShadowRangeIsAvailable() {
   AsanProcMaps procmaps;
-  uintptr_t start, end;
-  uintptr_t shadow_start = kLowShadowBeg;
+  uptr start, end;
+  uptr shadow_start = kLowShadowBeg;
   if (kLowShadowBeg > 0) shadow_start -= kMmapGranularity;
-  uintptr_t shadow_end = kHighShadowEnd;
+  uptr shadow_end = kHighShadowEnd;
   while (procmaps.Next(&start, &end,
-                       /*offset*/NULL, /*filename*/NULL, /*filename_size*/0)) {
+                       /*offset*/0, /*filename*/0, /*filename_size*/0)) {
     if (!IntervalsAreSeparate(start, end, shadow_start, shadow_end))
       return false;
   }
@@ -80,10 +80,10 @@ static void MaybeInstallSigaction(int signum,
 }
 
 static void     ASAN_OnSIGSEGV(int, siginfo_t *siginfo, void *context) {
-  uintptr_t addr = (uintptr_t)siginfo->si_addr;
+  uptr addr = (uptr)siginfo->si_addr;
   // Write the first message using the bullet-proof write.
   if (13 != AsanWrite(2, "ASAN:SIGSEGV\n", 13)) AsanDie();
-  uintptr_t pc, sp, bp;
+  uptr pc, sp, bp;
   GetPcSpBp(context, &pc, &sp, &bp);
   Report("ERROR: AddressSanitizer crashed on unknown address %p"
          " (pc %p sp %p bp %p T%d)\n",
@@ -97,7 +97,7 @@ static void     ASAN_OnSIGSEGV(int, siginfo_t *siginfo, void *context) {
 
 void SetAlternateSignalStack() {
   stack_t altstack, oldstack;
-  CHECK(0 == sigaltstack(NULL, &oldstack));
+  CHECK(0 == sigaltstack(0, &oldstack));
   // If the alternate stack is already in place, do nothing.
   if ((oldstack.ss_flags & SS_DISABLE) == 0) return;
   // TODO(glider): the mapped stack should have the MAP_STACK flag in the
@@ -107,7 +107,7 @@ void SetAlternateSignalStack() {
   altstack.ss_sp = base;
   altstack.ss_flags = 0;
   altstack.ss_size = kAltStackSize;
-  CHECK(0 == sigaltstack(&altstack, NULL));
+  CHECK(0 == sigaltstack(&altstack, 0));
   if (FLAG_v > 0) {
     Report("Alternative stack for T%d set: [%p,%p)\n",
            asanThreadRegistry().GetCurrentTidOrMinusOne(),
@@ -117,7 +117,7 @@ void SetAlternateSignalStack() {
 
 void UnsetAlternateSignalStack() {
   stack_t altstack, oldstack;
-  altstack.ss_sp = NULL;
+  altstack.ss_sp = 0;
   altstack.ss_flags = SS_DISABLE;
   altstack.ss_size = 0;
   CHECK(0 == sigaltstack(&altstack, &oldstack));
@@ -142,11 +142,11 @@ void AsanDisableCoreDumper() {
 
 void AsanDumpProcessMap() {
   AsanProcMaps proc_maps;
-  uintptr_t start, end;
+  uptr start, end;
   const intptr_t kBufSize = 4095;
   char filename[kBufSize];
   Report("Process memory map follows:\n");
-  while (proc_maps.Next(&start, &end, /* file_offset */NULL,
+  while (proc_maps.Next(&start, &end, /* file_offset */0,
                         filename, kBufSize)) {
     Printf("\t%p-%p\t%s\n", (void*)start, (void*)end, filename);
   }
@@ -157,8 +157,8 @@ int GetPid() {
   return getpid();
 }
 
-uintptr_t GetThreadSelf() {
-  return (uintptr_t)pthread_self();
+uptr GetThreadSelf() {
+  return (uptr)pthread_self();
 }
 
 void SleepForSeconds(int seconds) {
@@ -189,7 +189,7 @@ uint16_t AtomicExchange(uint16_t *a, uint16_t new_val) {
   return __sync_lock_test_and_set(a, new_val);
 }
 
-void SortArray(uintptr_t *array, size_t size) {
+void SortArray(uptr *array, uptr size) {
   std::sort(array, array + size);
 }
 
diff --git a/compiler-rt/lib/asan/asan_printf.cc b/compiler-rt/lib/asan/asan_printf.cc
index 69c34fa4f8f..a9f501ce206 100644
--- a/compiler-rt/lib/asan/asan_printf.cc
+++ b/compiler-rt/lib/asan/asan_printf.cc
@@ -23,11 +23,11 @@
 namespace __asan {
 
 extern char *error_message_buffer;
-extern size_t error_message_buffer_pos, error_message_buffer_size;
+extern uptr error_message_buffer_pos, error_message_buffer_size;
 
 void RawWrite(const char *buffer) {
   static const char *kRawWriteError = "RawWrite can't output requested buffer!";
-  size_t length = (size_t)internal_strlen(buffer);
+  uptr length = (uptr)internal_strlen(buffer);
   if (length != AsanWrite(2, buffer, length)) {
     AsanWrite(2, kRawWriteError, internal_strlen(kRawWriteError));
     AsanDie();
@@ -54,11 +54,11 @@ static inline int AppendChar(char **buff, const char *buff_end, char c) {
 // "minimal_num_length", it is padded with leading zeroes.
 static int AppendUnsigned(char **buff, const char *buff_end, uint64_t num,
                           uint8_t base, uint8_t minimal_num_length) {
-  size_t const kMaxLen = 30;
+  uptr const kMaxLen = 30;
   RAW_CHECK(base == 10 || base == 16);
   RAW_CHECK(minimal_num_length < kMaxLen);
-  size_t num_buffer[kMaxLen];
-  size_t pos = 0;
+  uptr num_buffer[kMaxLen];
+  uptr pos = 0;
   do {
     RAW_CHECK_MSG(pos < kMaxLen, "appendNumber buffer overflow");
     num_buffer[pos++] = num % base;
@@ -67,7 +67,7 @@ static int AppendUnsigned(char **buff, const char *buff_end, uint64_t num,
   while (pos < minimal_num_length) num_buffer[pos++] = 0;
   int result = 0;
   while (pos-- > 0) {
-    size_t digit = num_buffer[pos];
+    uptr digit = num_buffer[pos];
     result += AppendChar(buff, buff_end, (digit < 10) ? '0' + digit
                                                       : 'a' + digit - 10);
   }
@@ -88,7 +88,7 @@ static inline int AppendSignedDecimal(char **buff, const char *buff_end,
 static inline int AppendString(char **buff, const char *buff_end,
                                const char *s) {
   // Avoid library functions like stpcpy here.
-  RAW_CHECK_MSG(s, "Error: passing a NULL pointer to AppendString\n");
+  RAW_CHECK_MSG(s, "Error: passing a 0 pointer to AppendString\n");
   int result = 0;
   for (; *s; s++) {
     result += AppendChar(buff, buff_end, *s);
@@ -126,17 +126,17 @@ static int VSNPrintf(char *buff, int buff_length,
                                 : va_arg(args, int);
                   result += AppendSignedDecimal(&buff, buff_end, dval);
                   break;
-        case 'u': uval = have_z ? va_arg(args, size_t)
+        case 'u': uval = have_z ? va_arg(args, uptr)
                                 : va_arg(args, unsigned);
                   result += AppendUnsigned(&buff, buff_end, uval, 10, 0);
                   break;
-        case 'x': uval = have_z ? va_arg(args, size_t)
+        case 'x': uval = have_z ? va_arg(args, uptr)
                                 : va_arg(args, unsigned);
                   result += AppendUnsigned(&buff, buff_end, uval, 16, 0);
                   break;
         case 'p': RAW_CHECK_MSG(!have_z, kPrintfFormatsHelp);
                   result += AppendPointer(&buff, buff_end,
-                                          va_arg(args, uintptr_t));
+                                          va_arg(args, uptr));
                   break;
         case 's': RAW_CHECK_MSG(!have_z, kPrintfFormatsHelp);
                   result += AppendString(&buff, buff_end, va_arg(args, char*));
@@ -167,7 +167,7 @@ void Printf(const char *format, ...) {
 // Returns the number of symbols that should have been written to buffer
 // (not including trailing '\0'). Thus, the string is truncated
 // iff return value is not less than "length".
-int SNPrintf(char *buffer, size_t length, const char *format, ...) {
+int SNPrintf(char *buffer, uptr length, const char *format, ...) {
   va_list args;
   va_start(args, format);
   int needed_length = VSNPrintf(buffer, length, format, args);
diff --git a/compiler-rt/lib/asan/asan_procmaps.h b/compiler-rt/lib/asan/asan_procmaps.h
index 5ae5fb238b6..f660e312bdd 100644
--- a/compiler-rt/lib/asan/asan_procmaps.h
+++ b/compiler-rt/lib/asan/asan_procmaps.h
@@ -21,22 +21,22 @@ namespace __asan {
 class AsanProcMaps {
  public:
   AsanProcMaps();
-  bool Next(uintptr_t *start, uintptr_t *end, uintptr_t *offset,
-            char filename[], size_t filename_size);
+  bool Next(uptr *start, uptr *end, uptr *offset,
+            char filename[], uptr filename_size);
   void Reset();
   // Gets the object file name and the offset in that object for a given
   // address 'addr'. Returns true on success.
-  bool GetObjectNameAndOffset(uintptr_t addr, uintptr_t *offset,
-                              char filename[], size_t filename_size);
+  bool GetObjectNameAndOffset(uptr addr, uptr *offset,
+                              char filename[], uptr filename_size);
   ~AsanProcMaps();
  private:
   // Default implementation of GetObjectNameAndOffset.
   // Quite slow, because it iterates through the whole process map for each
   // lookup.
-  bool IterateForObjectNameAndOffset(uintptr_t addr, uintptr_t *offset,
-                                     char filename[], size_t filename_size) {
+  bool IterateForObjectNameAndOffset(uptr addr, uptr *offset,
+                                     char filename[], uptr filename_size) {
     Reset();
-    uintptr_t start, end, file_offset;
+    uptr start, end, file_offset;
     for (int i = 0; Next(&start, &end, &file_offset, filename, filename_size);
          i++) {
       if (addr >= start && addr < end) {
@@ -52,13 +52,13 @@ class AsanProcMaps {
 
 #if defined __linux__
   char *proc_self_maps_buff_;
-  size_t proc_self_maps_buff_mmaped_size_;
-  size_t proc_self_maps_buff_len_;
+  uptr proc_self_maps_buff_mmaped_size_;
+  uptr proc_self_maps_buff_len_;
   char *current_;
 #elif defined __APPLE__
   template<uint32_t kLCSegment, typename SegmentCommand>
-  bool NextSegmentLoad(uintptr_t *start, uintptr_t *end, uintptr_t *offset,
-                       char filename[], size_t filename_size);
+  bool NextSegmentLoad(uptr *start, uptr *end, uptr *offset,
+                       char filename[], uptr filename_size);
   int current_image_;
   uint32_t current_magic_;
   int current_load_cmd_count_;
diff --git a/compiler-rt/lib/asan/asan_rtl.cc b/compiler-rt/lib/asan/asan_rtl.cc
index 224caf4383a..e13768ab4dd 100644
--- a/compiler-rt/lib/asan/asan_rtl.cc
+++ b/compiler-rt/lib/asan/asan_rtl.cc
@@ -26,13 +26,13 @@ namespace __asan {
 using namespace __sanitizer;
 
 // -------------------------- Flags ------------------------- {{{1
-static const size_t kMallocContextSize = 30;
+static const uptr kMallocContextSize = 30;
 
-size_t  FLAG_malloc_context_size = kMallocContextSize;
-size_t  FLAG_max_malloc_fill_size = 0;
+uptr  FLAG_malloc_context_size = kMallocContextSize;
+uptr  FLAG_max_malloc_fill_size = 0;
 int64_t FLAG_v = 0;
-size_t  FLAG_redzone = (ASAN_LOW_MEMORY) ? 64 : 128;  // power of two, >= 32
-size_t  FLAG_quarantine_size = (ASAN_LOW_MEMORY) ? 1UL << 24 : 1UL << 28;
+uptr  FLAG_redzone = (ASAN_LOW_MEMORY) ? 64 : 128;  // power of two, >= 32
+uptr  FLAG_quarantine_size = (ASAN_LOW_MEMORY) ? 1UL << 24 : 1UL << 28;
 static int64_t    FLAG_atexit = 0;
 bool    FLAG_poison_shadow = 1;
 int64_t FLAG_report_globals = 1;
@@ -58,9 +58,9 @@ int asan_inited;
 bool asan_init_is_running;
 static void (*death_callback)(void);
 static void (*error_report_callback)(const char*);
-char *error_message_buffer = NULL;
-size_t error_message_buffer_pos = 0;
-size_t error_message_buffer_size = 0;
+char *error_message_buffer = 0;
+uptr error_message_buffer_pos = 0;
+uptr error_message_buffer_size = 0;
 
 // -------------------------- Misc ---------------- {{{1
 void ShowStatsAndAbort() {
@@ -68,24 +68,24 @@ void ShowStatsAndAbort() {
   AsanDie();
 }
 
-static void PrintBytes(const char *before, uintptr_t *a) {
+static void PrintBytes(const char *before, uptr *a) {
   uint8_t *bytes = (uint8_t*)a;
-  size_t byte_num = (__WORDSIZE) / 8;
+  uptr byte_num = (__WORDSIZE) / 8;
   Printf("%s%p:", before, (void*)a);
-  for (size_t i = 0; i < byte_num; i++) {
+  for (uptr i = 0; i < byte_num; i++) {
     Printf(" %x%x", bytes[i] >> 4, bytes[i] & 15);
   }
   Printf("\n");
 }
 
-size_t ReadFileToBuffer(const char *file_name, char **buff,
-                         size_t *buff_size, size_t max_len) {
-  const size_t kMinFileLen = kPageSize;
-  size_t read_len = 0;
+uptr ReadFileToBuffer(const char *file_name, char **buff,
+                         uptr *buff_size, uptr max_len) {
+  const uptr kMinFileLen = kPageSize;
+  uptr read_len = 0;
   *buff = 0;
   *buff_size = 0;
   // The files we usually open are not seekable, so try different buffer sizes.
-  for (size_t size = kMinFileLen; size <= max_len; size *= 2) {
+  for (uptr size = kMinFileLen; size <= max_len; size *= 2) {
     int fd = AsanOpenReadonly(file_name);
     if (fd < 0) return 0;
     AsanUnmapOrDie(*buff, *buff_size);
@@ -95,7 +95,7 @@ size_t ReadFileToBuffer(const char *file_name, char **buff,
     read_len = 0;
     bool reached_eof = false;
     while (read_len + kPageSize <= size) {
-      size_t just_read = AsanRead(fd, *buff + read_len, kPageSize);
+      uptr just_read = AsanRead(fd, *buff + read_len, kPageSize);
       if (just_read == 0) {
         reached_eof = true;
         break;
@@ -129,7 +129,7 @@ void AsanDie() {
 }
 
 // ---------------------- mmap -------------------- {{{1
-void OutOfMemoryMessageAndDie(const char *mem_type, size_t size) {
+void OutOfMemoryMessageAndDie(const char *mem_type, uptr size) {
   Report("ERROR: AddressSanitizer failed to allocate "
          "0x%zx (%zd) bytes of %s\n",
          size, size, mem_type);
@@ -138,23 +138,23 @@ void OutOfMemoryMessageAndDie(const char *mem_type, size_t size) {
 }
 
 // Reserve memory range [beg, end].
-static void ReserveShadowMemoryRange(uintptr_t beg, uintptr_t end) {
+static void ReserveShadowMemoryRange(uptr beg, uptr end) {
   CHECK((beg % kPageSize) == 0);
   CHECK(((end + 1) % kPageSize) == 0);
-  size_t size = end - beg + 1;
+  uptr size = end - beg + 1;
   void *res = AsanMmapFixedNoReserve(beg, size);
   CHECK(res == (void*)beg && "ReserveShadowMemoryRange failed");
 }
 
 // ---------------------- LowLevelAllocator ------------- {{{1
-void *LowLevelAllocator::Allocate(size_t size) {
+void *LowLevelAllocator::Allocate(uptr size) {
   CHECK((size & (size - 1)) == 0 && "size must be a power of two");
   if (allocated_end_ - allocated_current_ < size) {
-    size_t size_to_allocate = Max(size, kPageSize);
+    uptr size_to_allocate = Max(size, kPageSize);
     allocated_current_ =
         (char*)AsanMmapSomewhereOrDie(size_to_allocate, __FUNCTION__);
     allocated_end_ = allocated_current_ + size_to_allocate;
-    PoisonShadow((uintptr_t)allocated_current_, size_to_allocate,
+    PoisonShadow((uptr)allocated_current_, size_to_allocate,
                  kAsanInternalHeapMagic);
   }
   CHECK(allocated_end_ - allocated_current_ >= size);
@@ -164,12 +164,12 @@ void *LowLevelAllocator::Allocate(size_t size) {
 }
 
 // ---------------------- DescribeAddress -------------------- {{{1
-static bool DescribeStackAddress(uintptr_t addr, uintptr_t access_size) {
+static bool DescribeStackAddress(uptr addr, uptr access_size) {
   AsanThread *t = asanThreadRegistry().FindThreadByStackAddress(addr);
   if (!t) return false;
   const intptr_t kBufSize = 4095;
   char buf[kBufSize];
-  uintptr_t offset = 0;
+  uptr offset = 0;
   const char *frame_descr = t->GetFrameNameByAddr(addr, &offset);
   // This string is created by the compiler and has the following form:
   // "FunctioName n alloc_1 alloc_2 ... alloc_n"
@@ -187,12 +187,12 @@ static bool DescribeStackAddress(uintptr_t addr, uintptr_t access_size) {
          addr, offset, buf, t->tid());
   // Report the number of stack objects.
   char *p;
-  size_t n_objects = internal_simple_strtoll(name_end, &p, 10);
+  uptr n_objects = internal_simple_strtoll(name_end, &p, 10);
   CHECK(n_objects > 0);
   Printf("  This frame has %zu object(s):\n", n_objects);
   // Report all objects in this frame.
-  for (size_t i = 0; i < n_objects; i++) {
-    size_t beg, size;
+  for (uptr i = 0; i < n_objects; i++) {
+    uptr beg, size;
     intptr_t len;
     beg  = internal_simple_strtoll(p, &p, 10);
     size = internal_simple_strtoll(p, &p, 10);
@@ -215,7 +215,7 @@ static bool DescribeStackAddress(uintptr_t addr, uintptr_t access_size) {
   return true;
 }
 
-static NOINLINE void DescribeAddress(uintptr_t addr, uintptr_t access_size) {
+static NOINLINE void DescribeAddress(uptr addr, uptr access_size) {
   // Check if this is a global.
   if (DescribeAddrIfGlobal(addr))
     return;
@@ -231,8 +231,8 @@ static NOINLINE void DescribeAddress(uintptr_t addr, uintptr_t access_size) {
 // exported functions
 #define ASAN_REPORT_ERROR(type, is_write, size)                     \
 extern "C" NOINLINE ASAN_INTERFACE_ATTRIBUTE                        \
-void __asan_report_ ## type ## size(uintptr_t addr);                \
-void __asan_report_ ## type ## size(uintptr_t addr) {               \
+void __asan_report_ ## type ## size(uptr addr);                \
+void __asan_report_ ## type ## size(uptr addr) {               \
   GET_CALLER_PC_BP_SP;                                              \
   __asan_report_error(pc, bp, sp, addr, is_write, size);            \
 }
@@ -266,11 +266,11 @@ static NOINLINE void force_interface_symbols() {
     __asan_report_store4(0);
     __asan_report_store8(0);
     __asan_report_store16(0);
-    __asan_register_global(0, 0, NULL);
-    __asan_register_globals(NULL, 0);
-    __asan_unregister_globals(NULL, 0);
-    __asan_set_death_callback(NULL);
-    __asan_set_error_report_callback(NULL);
+    __asan_register_global(0, 0, 0);
+    __asan_register_globals(0, 0);
+    __asan_unregister_globals(0, 0);
+    __asan_set_death_callback(0);
+    __asan_set_error_report_callback(0);
     __asan_handle_no_return();
   }
 }
@@ -340,8 +340,8 @@ void NOINLINE __asan_handle_no_return() {
   int local_stack;
   AsanThread *curr_thread = asanThreadRegistry().GetCurrent();
   CHECK(curr_thread);
-  uintptr_t top = curr_thread->stack_top();
-  uintptr_t bottom = ((uintptr_t)&local_stack - kPageSize) & ~(kPageSize-1);
+  uptr top = curr_thread->stack_top();
+  uptr bottom = ((uptr)&local_stack - kPageSize) & ~(kPageSize-1);
   PoisonShadow(bottom, top - bottom, 0);
 }
 
@@ -421,7 +421,7 @@ void __asan_report_error(uptr pc, uptr bp, uptr sp,
          access_size, addr, curr_tid);
 
   if (FLAG_debug) {
-    PrintBytes("PC: ", (uintptr_t*)pc);
+    PrintBytes("PC: ", (uptr*)pc);
   }
 
   GET_STACK_TRACE_WITH_PC_AND_BP(kStackTraceMax, pc, bp);
@@ -431,23 +431,23 @@ void __asan_report_error(uptr pc, uptr bp, uptr sp,
 
   DescribeAddress(addr, access_size);
 
-  uintptr_t shadow_addr = MemToShadow(addr);
+  uptr shadow_addr = MemToShadow(addr);
   Report("ABORTING\n");
   __asan_print_accumulated_stats();
   Printf("Shadow byte and word:\n");
   Printf("  %p: %x\n", shadow_addr, *(unsigned char*)shadow_addr);
-  uintptr_t aligned_shadow = shadow_addr & ~(kWordSize - 1);
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow));
+  uptr aligned_shadow = shadow_addr & ~(kWordSize - 1);
+  PrintBytes("  ", (uptr*)(aligned_shadow));
   Printf("More shadow bytes:\n");
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow-4*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow-3*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow-2*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow-1*kWordSize));
-  PrintBytes("=>", (uintptr_t*)(aligned_shadow+0*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow+1*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow+2*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow+3*kWordSize));
-  PrintBytes("  ", (uintptr_t*)(aligned_shadow+4*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow-4*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow-3*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow-2*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow-1*kWordSize));
+  PrintBytes("=>", (uptr*)(aligned_shadow+0*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow+1*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow+2*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow+3*kWordSize));
+  PrintBytes("  ", (uptr*)(aligned_shadow+4*kWordSize));
   if (error_report_callback) {
     error_report_callback(error_message_buffer);
   }
@@ -544,12 +544,12 @@ void __asan_init() {
            MEM_TO_SHADOW(kLowShadowEnd),
            MEM_TO_SHADOW(kHighShadowBeg),
            MEM_TO_SHADOW(kHighShadowEnd));
-    Printf("red_zone=%zu\n", (size_t)FLAG_redzone);
-    Printf("malloc_context_size=%zu\n", (size_t)FLAG_malloc_context_size);
+    Printf("red_zone=%zu\n", (uptr)FLAG_redzone);
+    Printf("malloc_context_size=%zu\n", (uptr)FLAG_malloc_context_size);
 
-    Printf("SHADOW_SCALE: %zx\n", (size_t)SHADOW_SCALE);
-    Printf("SHADOW_GRANULARITY: %zx\n", (size_t)SHADOW_GRANULARITY);
-    Printf("SHADOW_OFFSET: %zx\n", (size_t)SHADOW_OFFSET);
+    Printf("SHADOW_SCALE: %zx\n", (uptr)SHADOW_SCALE);
+    Printf("SHADOW_GRANULARITY: %zx\n", (uptr)SHADOW_GRANULARITY);
+    Printf("SHADOW_OFFSET: %zx\n", (uptr)SHADOW_OFFSET);
     CHECK(SHADOW_SCALE >= 3 && SHADOW_SCALE <= 7);
   }
 
diff --git a/compiler-rt/lib/asan/asan_stack.cc b/compiler-rt/lib/asan/asan_stack.cc
index a8766bbbbc4..571a2ffb0e7 100644
--- a/compiler-rt/lib/asan/asan_stack.cc
+++ b/compiler-rt/lib/asan/asan_stack.cc
@@ -27,9 +27,9 @@ namespace __asan {
 
 // ----------------------- AsanStackTrace ----------------------------- {{{1
 #if defined(ASAN_USE_EXTERNAL_SYMBOLIZER)
-void AsanStackTrace::PrintStack(uintptr_t *addr, size_t size) {
-  for (size_t i = 0; i < size && addr[i]; i++) {
-    uintptr_t pc = addr[i];
+void AsanStackTrace::PrintStack(uptr *addr, uptr size) {
+  for (uptr i = 0; i < size && addr[i]; i++) {
+    uptr pc = addr[i];
     char buff[4096];
     ASAN_USE_EXTERNAL_SYMBOLIZER((void*)pc, buff, sizeof(buff));
     Printf("  #%zu 0x%zx %s\n", i, pc, buff);
@@ -37,12 +37,12 @@ void AsanStackTrace::PrintStack(uintptr_t *addr, size_t size) {
 }
 
 #else  // ASAN_USE_EXTERNAL_SYMBOLIZER
-void AsanStackTrace::PrintStack(uintptr_t *addr, size_t size) {
+void AsanStackTrace::PrintStack(uptr *addr, uptr size) {
   AsanProcMaps proc_maps;
-  for (size_t i = 0; i < size && addr[i]; i++) {
+  for (uptr i = 0; i < size && addr[i]; i++) {
     proc_maps.Reset();
-    uintptr_t pc = addr[i];
-    uintptr_t offset;
+    uptr pc = addr[i];
+    uptr offset;
     char filename[4096];
     if (proc_maps.GetObjectNameAndOffset(pc, &offset,
                                          filename, sizeof(filename))) {
@@ -54,66 +54,66 @@ void AsanStackTrace::PrintStack(uintptr_t *addr, size_t size) {
 }
 #endif  // ASAN_USE_EXTERNAL_SYMBOLIZER
 
-uintptr_t AsanStackTrace::GetCurrentPc() {
+uptr AsanStackTrace::GetCurrentPc() {
   return GET_CALLER_PC();
 }
 
-void AsanStackTrace::FastUnwindStack(uintptr_t pc, uintptr_t bp) {
+void AsanStackTrace::FastUnwindStack(uptr pc, uptr bp) {
   CHECK(size == 0 && trace[0] == pc);
   size = 1;
   if (!asan_inited) return;
   AsanThread *t = asanThreadRegistry().GetCurrent();
   if (!t) return;
-  uintptr_t *frame = (uintptr_t*)bp;
-  uintptr_t *prev_frame = frame;
-  uintptr_t *top = (uintptr_t*)t->stack_top();
-  uintptr_t *bottom = (uintptr_t*)t->stack_bottom();
+  uptr *frame = (uptr*)bp;
+  uptr *prev_frame = frame;
+  uptr *top = (uptr*)t->stack_top();
+  uptr *bottom = (uptr*)t->stack_bottom();
   while (frame >= prev_frame &&
          frame < top - 2 &&
          frame > bottom &&
          size < max_size) {
-    uintptr_t pc1 = frame[1];
+    uptr pc1 = frame[1];
     if (pc1 != pc) {
       trace[size++] = pc1;
     }
     prev_frame = frame;
-    frame = (uintptr_t*)frame[0];
+    frame = (uptr*)frame[0];
   }
 }
 
 // On 32-bits we don't compress stack traces.
 // On 64-bits we compress stack traces: if a given pc differes slightly from
 // the previous one, we record a 31-bit offset instead of the full pc.
-size_t AsanStackTrace::CompressStack(AsanStackTrace *stack,
-                                   uint32_t *compressed, size_t size) {
+uptr AsanStackTrace::CompressStack(AsanStackTrace *stack,
+                                   uint32_t *compressed, uptr size) {
 #if __WORDSIZE == 32
   // Don't compress, just copy.
-  size_t res = 0;
-  for (size_t i = 0; i < stack->size && i < size; i++) {
+  uptr res = 0;
+  for (uptr i = 0; i < stack->size && i < size; i++) {
     compressed[i] = stack->trace[i];
     res++;
   }
   if (stack->size < size)
     compressed[stack->size] = 0;
 #else  // 64 bits, compress.
-  uintptr_t prev_pc = 0;
-  const uintptr_t kMaxOffset = (1ULL << 30) - 1;
-  uintptr_t c_index = 0;
-  size_t res = 0;
-  for (size_t i = 0, n = stack->size; i < n; i++) {
-    uintptr_t pc = stack->trace[i];
+  uptr prev_pc = 0;
+  const uptr kMaxOffset = (1ULL << 30) - 1;
+  uptr c_index = 0;
+  uptr res = 0;
+  for (uptr i = 0, n = stack->size; i < n; i++) {
+    uptr pc = stack->trace[i];
     if (!pc) break;
     if ((int64_t)pc < 0) break;
     // Printf("C pc[%zu] %zx\n", i, pc);
     if (prev_pc - pc < kMaxOffset || pc - prev_pc < kMaxOffset) {
-      uintptr_t offset = (int64_t)(pc - prev_pc);
+      uptr offset = (int64_t)(pc - prev_pc);
       offset |= (1U << 31);
       if (c_index >= size) break;
       // Printf("C co[%zu] offset %zx\n", i, offset);
       compressed[c_index++] = offset;
     } else {
-      uintptr_t hi = pc >> 32;
-      uintptr_t lo = (pc << 32) >> 32;
+      uptr hi = pc >> 32;
+      uptr lo = (pc << 32) >> 32;
       CHECK((hi & (1 << 31)) == 0);
       if (c_index + 1 >= size) break;
       // Printf("C co[%zu] hi/lo: %zx %zx\n", c_index, hi, lo);
@@ -141,28 +141,28 @@ size_t AsanStackTrace::CompressStack(AsanStackTrace *stack,
   // UncompressStack(CompressStack(stack)) eliminates the 0x0 frames.
   CHECK(res >= check_stack.size);
   CHECK(0 == REAL(memcmp)(check_stack.trace, stack->trace,
-                          check_stack.size * sizeof(uintptr_t)));
+                          check_stack.size * sizeof(uptr)));
 #endif
 
   return res;
 }
 
 void AsanStackTrace::UncompressStack(AsanStackTrace *stack,
-                                     uint32_t *compressed, size_t size) {
+                                     uint32_t *compressed, uptr size) {
 #if __WORDSIZE == 32
   // Don't uncompress, just copy.
   stack->size = 0;
-  for (size_t i = 0; i < size && i < kStackTraceMax; i++) {
+  for (uptr i = 0; i < size && i < kStackTraceMax; i++) {
     if (!compressed[i]) break;
     stack->size++;
     stack->trace[i] = compressed[i];
   }
 #else  // 64 bits, uncompress
-  uintptr_t prev_pc = 0;
+  uptr prev_pc = 0;
   stack->size = 0;
-  for (size_t i = 0; i < size && stack->size < kStackTraceMax; i++) {
+  for (uptr i = 0; i < size && stack->size < kStackTraceMax; i++) {
     uint32_t x = compressed[i];
-    uintptr_t pc = 0;
+    uptr pc = 0;
     if (x & (1U << 31)) {
       // Printf("U co[%zu] offset: %x\n", i, x);
       // this is an offset
@@ -173,8 +173,8 @@ void AsanStackTrace::UncompressStack(AsanStackTrace *stack,
     } else {
       // CHECK(i + 1 < size);
       if (i + 1 >= size) break;
-      uintptr_t hi = x;
-      uintptr_t lo = compressed[i+1];
+      uptr hi = x;
+      uptr lo = compressed[i+1];
       // Printf("U co[%zu] hi/lo: %zx %zx\n", i, hi, lo);
       i++;
       pc = (hi << 32) | lo;
diff --git a/compiler-rt/lib/asan/asan_stack.h b/compiler-rt/lib/asan/asan_stack.h
index 252df93c84c..a754515c19c 100644
--- a/compiler-rt/lib/asan/asan_stack.h
+++ b/compiler-rt/lib/asan/asan_stack.h
@@ -18,41 +18,41 @@
 
 namespace __asan {
 
-static const size_t kStackTraceMax = 64;
+static const uptr kStackTraceMax = 64;
 
 struct AsanStackTrace {
-  size_t size;
-  size_t max_size;
-  uintptr_t trace[kStackTraceMax];
-  static void PrintStack(uintptr_t *addr, size_t size);
+  uptr size;
+  uptr max_size;
+  uptr trace[kStackTraceMax];
+  static void PrintStack(uptr *addr, uptr size);
   void PrintStack() {
     PrintStack(this->trace, this->size);
   }
-  void CopyTo(uintptr_t *dst, size_t dst_size) {
-    for (size_t i = 0; i < size && i < dst_size; i++)
+  void CopyTo(uptr *dst, uptr dst_size) {
+    for (uptr i = 0; i < size && i < dst_size; i++)
       dst[i] = trace[i];
-    for (size_t i = size; i < dst_size; i++)
+    for (uptr i = size; i < dst_size; i++)
       dst[i] = 0;
   }
 
-  void CopyFrom(uintptr_t *src, size_t src_size) {
+  void CopyFrom(uptr *src, uptr src_size) {
     size = src_size;
     if (size > kStackTraceMax) size = kStackTraceMax;
-    for (size_t i = 0; i < size; i++) {
+    for (uptr i = 0; i < size; i++) {
       trace[i] = src[i];
     }
   }
 
-  void GetStackTrace(size_t max_s, uintptr_t pc, uintptr_t bp);
+  void GetStackTrace(uptr max_s, uptr pc, uptr bp);
 
-  void FastUnwindStack(uintptr_t pc, uintptr_t bp);
+  void FastUnwindStack(uptr pc, uptr bp);
 
-  static uintptr_t GetCurrentPc();
+  static uptr GetCurrentPc();
 
-  static size_t CompressStack(AsanStackTrace *stack,
-                            uint32_t *compressed, size_t size);
+  static uptr CompressStack(AsanStackTrace *stack,
+                            uint32_t *compressed, uptr size);
   static void UncompressStack(AsanStackTrace *stack,
-                              uint32_t *compressed, size_t size);
+                              uint32_t *compressed, uptr size);
 };
 
 }  // namespace __asan
@@ -60,18 +60,18 @@ struct AsanStackTrace {
 // Use this macro if you want to print stack trace with the caller
 // of the current function in the top frame.
 #define GET_CALLER_PC_BP_SP \
-  uintptr_t bp = GET_CURRENT_FRAME();              \
-  uintptr_t pc = GET_CALLER_PC();                  \
-  uintptr_t local_stack;                           \
-  uintptr_t sp = (uintptr_t)&local_stack;
+  uptr bp = GET_CURRENT_FRAME();              \
+  uptr pc = GET_CALLER_PC();                  \
+  uptr local_stack;                           \
+  uptr sp = (uptr)&local_stack;
 
 // Use this macro if you want to print stack trace with the current
 // function in the top frame.
 #define GET_CURRENT_PC_BP_SP \
-  uintptr_t bp = GET_CURRENT_FRAME();              \
-  uintptr_t pc = AsanStackTrace::GetCurrentPc();   \
-  uintptr_t local_stack;                           \
-  uintptr_t sp = (uintptr_t)&local_stack;
+  uptr bp = GET_CURRENT_FRAME();              \
+  uptr pc = AsanStackTrace::GetCurrentPc();   \
+  uptr local_stack;                           \
+  uptr sp = (uptr)&local_stack;
 
 // Get the stack trace with the given pc and bp.
 // The pc will be in the position 0 of the resulting stack trace.
diff --git a/compiler-rt/lib/asan/asan_stats.cc b/compiler-rt/lib/asan/asan_stats.cc
index ea01a22dfa8..b697c5dfbc7 100644
--- a/compiler-rt/lib/asan/asan_stats.cc
+++ b/compiler-rt/lib/asan/asan_stats.cc
@@ -21,14 +21,14 @@
 namespace __asan {
 
 AsanStats::AsanStats() {
-  CHECK(REAL(memset) != NULL);
+  CHECK(REAL(memset) != 0);
   REAL(memset)(this, 0, sizeof(AsanStats));
 }
 
 static void PrintMallocStatsArray(const char *prefix,
-                                  size_t (&array)[kNumberOfSizeClasses]) {
+                                  uptr (&array)[kNumberOfSizeClasses]) {
   Printf("%s", prefix);
-  for (size_t i = 0; i < kNumberOfSizeClasses; i++) {
+  for (uptr i = 0; i < kNumberOfSizeClasses; i++) {
     if (!array[i]) continue;
     Printf("%zu:%zu; ", i, array[i]);
   }
diff --git a/compiler-rt/lib/asan/asan_stats.h b/compiler-rt/lib/asan/asan_stats.h
index d6dd084c013..b4c63f44fc6 100644
--- a/compiler-rt/lib/asan/asan_stats.h
+++ b/compiler-rt/lib/asan/asan_stats.h
@@ -23,27 +23,27 @@ namespace __asan {
 // Each AsanThread has its own AsanStats, which are sometimes flushed
 // to the accumulated AsanStats.
 struct AsanStats {
-  // AsanStats must be a struct consisting of size_t fields only.
-  // When merging two AsanStats structs, we treat them as arrays of size_t.
-  size_t mallocs;
-  size_t malloced;
-  size_t malloced_redzones;
-  size_t frees;
-  size_t freed;
-  size_t real_frees;
-  size_t really_freed;
-  size_t really_freed_redzones;
-  size_t reallocs;
-  size_t realloced;
-  size_t mmaps;
-  size_t mmaped;
-  size_t mmaped_by_size[kNumberOfSizeClasses];
-  size_t malloced_by_size[kNumberOfSizeClasses];
-  size_t freed_by_size[kNumberOfSizeClasses];
-  size_t really_freed_by_size[kNumberOfSizeClasses];
-
-  size_t malloc_large;
-  size_t malloc_small_slow;
+  // AsanStats must be a struct consisting of uptr fields only.
+  // When merging two AsanStats structs, we treat them as arrays of uptr.
+  uptr mallocs;
+  uptr malloced;
+  uptr malloced_redzones;
+  uptr frees;
+  uptr freed;
+  uptr real_frees;
+  uptr really_freed;
+  uptr really_freed_redzones;
+  uptr reallocs;
+  uptr realloced;
+  uptr mmaps;
+  uptr mmaped;
+  uptr mmaped_by_size[kNumberOfSizeClasses];
+  uptr malloced_by_size[kNumberOfSizeClasses];
+  uptr freed_by_size[kNumberOfSizeClasses];
+  uptr really_freed_by_size[kNumberOfSizeClasses];
+
+  uptr malloc_large;
+  uptr malloc_small_slow;
 
   // Ctor for global AsanStats (accumulated stats and main thread stats).
   explicit AsanStats(LinkerInitialized) { }
diff --git a/compiler-rt/lib/asan/asan_thread.cc b/compiler-rt/lib/asan/asan_thread.cc
index 0ebbe585d7c..da5ab3d4764 100644
--- a/compiler-rt/lib/asan/asan_thread.cc
+++ b/compiler-rt/lib/asan/asan_thread.cc
@@ -28,7 +28,7 @@ AsanThread::AsanThread(LinkerInitialized x)
 
 AsanThread *AsanThread::Create(int parent_tid, thread_callback_t start_routine,
                                void *arg, AsanStackTrace *stack) {
-  size_t size = RoundUpTo(sizeof(AsanThread), kPageSize);
+  uptr size = RoundUpTo(sizeof(AsanThread), kPageSize);
   AsanThread *thread = (AsanThread*)AsanMmapSomewhereOrDie(size, __FUNCTION__);
   thread->start_routine_ = start_routine;
   thread->arg_ = arg;
@@ -56,13 +56,13 @@ void AsanThread::Destroy() {
   }
 
   asanThreadRegistry().UnregisterThread(this);
-  CHECK(summary()->thread() == NULL);
+  CHECK(summary()->thread() == 0);
   // We also clear the shadow on thread destruction because
   // some code may still be executing in later TSD destructors
   // and we don't want it to have any poisoned stack.
   ClearShadowForThreadStack();
   fake_stack().Cleanup();
-  size_t size = RoundUpTo(sizeof(AsanThread), kPageSize);
+  uptr size = RoundUpTo(sizeof(AsanThread), kPageSize);
   AsanUnmapOrDie(this, size);
 }
 
@@ -85,7 +85,7 @@ thread_return_t AsanThread::ThreadStart() {
   if (FLAG_use_sigaltstack) SetAlternateSignalStack();
 
   if (!start_routine_) {
-    // start_routine_ == NULL if we're on the main thread or on one of the
+    // start_routine_ == 0 if we're on the main thread or on one of the
     // OS X libdispatch worker threads. But nobody is supposed to call
     // ThreadStart() for the worker threads.
     CHECK(tid() == 0);
@@ -105,8 +105,8 @@ void AsanThread::ClearShadowForThreadStack() {
   PoisonShadow(stack_bottom_, stack_top_ - stack_bottom_, 0);
 }
 
-const char *AsanThread::GetFrameNameByAddr(uintptr_t addr, uintptr_t *offset) {
-  uintptr_t bottom = 0;
+const char *AsanThread::GetFrameNameByAddr(uptr addr, uptr *offset) {
+  uptr bottom = 0;
   bool is_fake_stack = false;
   if (AddrIsInStack(addr)) {
     bottom = stack_bottom();
@@ -115,7 +115,7 @@ const char *AsanThread::GetFrameNameByAddr(uintptr_t addr, uintptr_t *offset) {
     CHECK(bottom);
     is_fake_stack = true;
   }
-  uintptr_t aligned_addr = addr & ~(__WORDSIZE/8 - 1);  // align addr.
+  uptr aligned_addr = addr & ~(__WORDSIZE/8 - 1);  // align addr.
   uint8_t *shadow_ptr = (uint8_t*)MemToShadow(aligned_addr);
   uint8_t *shadow_bottom = (uint8_t*)MemToShadow(bottom);
 
@@ -134,10 +134,10 @@ const char *AsanThread::GetFrameNameByAddr(uintptr_t addr, uintptr_t *offset) {
     return "UNKNOWN";
   }
 
-  uintptr_t* ptr = (uintptr_t*)SHADOW_TO_MEM((uintptr_t)(shadow_ptr + 1));
+  uptr* ptr = (uptr*)SHADOW_TO_MEM((uptr)(shadow_ptr + 1));
   CHECK((ptr[0] == kCurrentStackFrameMagic) ||
       (is_fake_stack && ptr[0] == kRetiredStackFrameMagic));
-  *offset = addr - (uintptr_t)ptr;
+  *offset = addr - (uptr)ptr;
   return (const char*)ptr[1];
 }
 
diff --git a/compiler-rt/lib/asan/asan_thread.h b/compiler-rt/lib/asan/asan_thread.h
index 200d306d892..e76c99b7af5 100644
--- a/compiler-rt/lib/asan/asan_thread.h
+++ b/compiler-rt/lib/asan/asan_thread.h
@@ -70,16 +70,16 @@ class AsanThread {
   void Init();  // Should be called from the thread itself.
   thread_return_t ThreadStart();
 
-  uintptr_t stack_top() { return stack_top_; }
-  uintptr_t stack_bottom() { return stack_bottom_; }
-  size_t stack_size() { return stack_top_ - stack_bottom_; }
+  uptr stack_top() { return stack_top_; }
+  uptr stack_bottom() { return stack_bottom_; }
+  uptr stack_size() { return stack_top_ - stack_bottom_; }
   int tid() { return summary_->tid(); }
   AsanThreadSummary *summary() { return summary_; }
   void set_summary(AsanThreadSummary *summary) { summary_ = summary; }
 
-  const char *GetFrameNameByAddr(uintptr_t addr, uintptr_t *offset);
+  const char *GetFrameNameByAddr(uptr addr, uptr *offset);
 
-  bool AddrIsInStack(uintptr_t addr) {
+  bool AddrIsInStack(uptr addr) {
     return addr >= stack_bottom_ && addr < stack_top_;
   }
 
@@ -96,8 +96,8 @@ class AsanThread {
   AsanThreadSummary *summary_;
   thread_callback_t start_routine_;
   void *arg_;
-  uintptr_t  stack_top_;
-  uintptr_t  stack_bottom_;
+  uptr  stack_top_;
+  uptr  stack_bottom_;
 
   FakeStack fake_stack_;
   AsanThreadLocalMallocStorage malloc_storage_;
diff --git a/compiler-rt/lib/asan/asan_thread_registry.cc b/compiler-rt/lib/asan/asan_thread_registry.cc
index 09f90fa24a6..1aae4980155 100644
--- a/compiler-rt/lib/asan/asan_thread_registry.cc
+++ b/compiler-rt/lib/asan/asan_thread_registry.cc
@@ -48,7 +48,7 @@ void AsanThreadRegistry::RegisterThread(AsanThread *thread) {
   CHECK(n_threads_ < kMaxNumberOfThreads);
 
   AsanThreadSummary *summary = thread->summary();
-  CHECK(summary != NULL);
+  CHECK(summary != 0);
   summary->set_tid(tid);
   thread_summaries_[tid] = summary;
 }
@@ -58,7 +58,7 @@ void AsanThreadRegistry::UnregisterThread(AsanThread *thread) {
   FlushToAccumulatedStatsUnlocked(&thread->stats());
   AsanThreadSummary *summary = thread->summary();
   CHECK(summary);
-  summary->set_thread(NULL);
+  summary->set_thread(0);
 }
 
 AsanThread *AsanThreadRegistry::GetMain() {
@@ -74,7 +74,7 @@ AsanThread *AsanThreadRegistry::GetCurrent() {
     // address. We are not entirely sure that we have correct main thread
     // limits, so only do this magic on Android, and only if the found thread is
     // the main thread.
-    AsanThread* thread = FindThreadByStackAddress((uintptr_t)&summary);
+    AsanThread* thread = FindThreadByStackAddress((uptr)&summary);
     if (thread && thread->tid() == 0) {
       SetCurrent(thread);
       return thread;
@@ -107,19 +107,19 @@ AsanStats AsanThreadRegistry::GetAccumulatedStats() {
   return accumulated_stats_;
 }
 
-size_t AsanThreadRegistry::GetCurrentAllocatedBytes() {
+uptr AsanThreadRegistry::GetCurrentAllocatedBytes() {
   ScopedLock lock(&mu_);
   UpdateAccumulatedStatsUnlocked();
   return accumulated_stats_.malloced - accumulated_stats_.freed;
 }
 
-size_t AsanThreadRegistry::GetHeapSize() {
+uptr AsanThreadRegistry::GetHeapSize() {
   ScopedLock lock(&mu_);
   UpdateAccumulatedStatsUnlocked();
   return accumulated_stats_.mmaped;
 }
 
-size_t AsanThreadRegistry::GetFreeBytes() {
+uptr AsanThreadRegistry::GetFreeBytes() {
   ScopedLock lock(&mu_);
   UpdateAccumulatedStatsUnlocked();
   return accumulated_stats_.mmaped
@@ -136,7 +136,7 @@ AsanThreadSummary *AsanThreadRegistry::FindByTid(int tid) {
   return thread_summaries_[tid];
 }
 
-AsanThread *AsanThreadRegistry::FindThreadByStackAddress(uintptr_t addr) {
+AsanThread *AsanThreadRegistry::FindThreadByStackAddress(uptr addr) {
   ScopedLock lock(&mu_);
   // Main thread (tid = 0) stack limits are pretty much guessed; for the other
   // threads we ask libpthread, so their limits must be correct.
@@ -154,18 +154,18 @@ AsanThread *AsanThreadRegistry::FindThreadByStackAddress(uintptr_t addr) {
 void AsanThreadRegistry::UpdateAccumulatedStatsUnlocked() {
   for (int tid = 0; tid < n_threads_; tid++) {
     AsanThread *t = thread_summaries_[tid]->thread();
-    if (t != NULL) {
+    if (t != 0) {
       FlushToAccumulatedStatsUnlocked(&t->stats());
     }
   }
 }
 
 void AsanThreadRegistry::FlushToAccumulatedStatsUnlocked(AsanStats *stats) {
-  // AsanStats consists of variables of type size_t only.
-  size_t *dst = (size_t*)&accumulated_stats_;
-  size_t *src = (size_t*)stats;
-  size_t num_fields = sizeof(AsanStats) / sizeof(size_t);
-  for (size_t i = 0; i < num_fields; i++) {
+  // AsanStats consists of variables of type uptr only.
+  uptr *dst = (uptr*)&accumulated_stats_;
+  uptr *src = (uptr*)stats;
+  uptr num_fields = sizeof(AsanStats) / sizeof(uptr);
+  for (uptr i = 0; i < num_fields; i++) {
     dst[i] += src[i];
     src[i] = 0;
   }
diff --git a/compiler-rt/lib/asan/asan_thread_registry.h b/compiler-rt/lib/asan/asan_thread_registry.h
index 491101e748b..7a3ad6aba24 100644
--- a/compiler-rt/lib/asan/asan_thread_registry.h
+++ b/compiler-rt/lib/asan/asan_thread_registry.h
@@ -34,7 +34,7 @@ class AsanThreadRegistry {
   void UnregisterThread(AsanThread *thread);
 
   AsanThread *GetMain();
-  // Get the current thread. May return NULL.
+  // Get the current thread. May return 0.
   AsanThread *GetCurrent();
   void SetCurrent(AsanThread *t);
 
@@ -45,17 +45,17 @@ class AsanThreadRegistry {
   }
 
   // Returns stats for GetCurrent(), or stats for
-  // T0 if GetCurrent() returns NULL.
+  // T0 if GetCurrent() returns 0.
   AsanStats &GetCurrentThreadStats();
   // Flushes all thread-local stats to accumulated stats, and returns
   // a copy of accumulated stats.
   AsanStats GetAccumulatedStats();
-  size_t GetCurrentAllocatedBytes();
-  size_t GetHeapSize();
-  size_t GetFreeBytes();
+  uptr GetCurrentAllocatedBytes();
+  uptr GetHeapSize();
+  uptr GetFreeBytes();
 
   AsanThreadSummary *FindByTid(int tid);
-  AsanThread *FindThreadByStackAddress(uintptr_t addr);
+  AsanThread *FindThreadByStackAddress(uptr addr);
 
  private:
   void UpdateAccumulatedStatsUnlocked();
diff --git a/compiler-rt/lib/asan/asan_win.cc b/compiler-rt/lib/asan/asan_win.cc
index 801fee5adbb..b5f1b304958 100644
--- a/compiler-rt/lib/asan/asan_win.cc
+++ b/compiler-rt/lib/asan/asan_win.cc
@@ -32,19 +32,19 @@
 namespace __asan {
 
 // ---------------------- Memory management ---------------- {{{1
-void *AsanMmapFixedNoReserve(uintptr_t fixed_addr, size_t size) {
+void *AsanMmapFixedNoReserve(uptr fixed_addr, size_t size) {
   return VirtualAlloc((LPVOID)fixed_addr, size,
                       MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
 }
 
 void *AsanMmapSomewhereOrDie(size_t size, const char *mem_type) {
-  void *rv = VirtualAlloc(NULL, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-  if (rv == NULL)
+  void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+  if (rv == 0)
     OutOfMemoryMessageAndDie(mem_type, size);
   return rv;
 }
 
-void *AsanMprotect(uintptr_t fixed_addr, size_t size) {
+void *AsanMprotect(uptr fixed_addr, size_t size) {
   return VirtualAlloc((LPVOID)fixed_addr, size,
                       MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
 }
@@ -59,10 +59,10 @@ size_t AsanWrite(int fd, const void *buf, size_t count) {
     UNIMPLEMENTED();
 
   HANDLE err = GetStdHandle(STD_ERROR_HANDLE);
-  if (err == NULL)
+  if (err == 0)
     return 0;  // FIXME: this might not work on some apps.
   DWORD ret;
-  if (!WriteFile(err, buf, count, &ret, NULL))
+  if (!WriteFile(err, buf, count, &ret, 0))
     return 0;
   return ret;
 }
@@ -93,23 +93,23 @@ void AsanThread::SetThreadStackTopAndBottom() {
   // FIXME: is it possible for the stack to not be a single allocation?
   // Are these values what ASan expects to get (reserved, not committed;
   // including stack guard page) ?
-  stack_top_ = (uintptr_t)mbi.BaseAddress + mbi.RegionSize;
-  stack_bottom_ = (uintptr_t)mbi.AllocationBase;
+  stack_top_ = (uptr)mbi.BaseAddress + mbi.RegionSize;
+  stack_bottom_ = (uptr)mbi.AllocationBase;
 }
 
-void AsanStackTrace::GetStackTrace(size_t max_s, uintptr_t pc, uintptr_t bp) {
+void AsanStackTrace::GetStackTrace(size_t max_s, uptr pc, uptr bp) {
   max_size = max_s;
   void *tmp[kStackTraceMax];
 
   // FIXME: CaptureStackBackTrace might be too slow for us.
   // FIXME: Compare with StackWalk64.
   // FIXME: Look at LLVMUnhandledExceptionFilter in Signals.inc
-  size_t cs_ret = CaptureStackBackTrace(1, max_size, tmp, NULL),
+  size_t cs_ret = CaptureStackBackTrace(1, max_size, tmp, 0),
          offset = 0;
   // Skip the RTL frames by searching for the PC in the stacktrace.
   // FIXME: this doesn't work well for the malloc/free stacks yet.
   for (size_t i = 0; i < cs_ret; i++) {
-    if (pc != (uintptr_t)tmp[i])
+    if (pc != (uptr)tmp[i])
       continue;
     offset = i;
     break;
@@ -117,7 +117,7 @@ void AsanStackTrace::GetStackTrace(size_t max_s, uintptr_t pc, uintptr_t bp) {
 
   size = cs_ret - offset;
   for (size_t i = 0; i < size; i++)
-    trace[i] = (uintptr_t)tmp[i + offset];
+    trace[i] = (uptr)tmp[i + offset];
 }
 
 bool __asan_WinSymbolize(const void *addr, char *out_buffer, int buffer_size) {
@@ -126,7 +126,7 @@ bool __asan_WinSymbolize(const void *addr, char *out_buffer, int buffer_size) {
     SymSetOptions(SYMOPT_DEFERRED_LOADS |
                   SYMOPT_UNDNAME |
                   SYMOPT_LOAD_LINES);
-    CHECK(SymInitialize(GetCurrentProcess(), NULL, TRUE));
+    CHECK(SymInitialize(GetCurrentProcess(), 0, TRUE));
     // FIXME: We don't call SymCleanup() on exit yet - should we?
     dbghelp_initialized = true;
   }
@@ -200,7 +200,7 @@ void AsanLock::Unlock() {
 // ---------------------- TSD ---------------- {{{1
 static bool tsd_key_inited = false;
 
-static __declspec(thread) void *fake_tsd = NULL;
+static __declspec(thread) void *fake_tsd = 0;
 
 void AsanTSDInit(void (*destructor)(void *tsd)) {
   // FIXME: we're ignoring the destructor for now.
@@ -222,7 +222,7 @@ void *AsanDoesNotSupportStaticLinkage() {
 #if defined(_DEBUG)
 #error Please build the runtime with a non-debug CRT: /MD or /MT
 #endif
-  return NULL;
+  return 0;
 }
 
 bool AsanShadowRangeIsAvailable() {
@@ -260,7 +260,7 @@ const char* AsanGetEnv(const char* name) {
   DWORD rv = GetEnvironmentVariableA(name, env_buffer, sizeof(env_buffer));
   if (rv > 0 && rv < sizeof(env_buffer))
     return env_buffer;
-  return NULL;
+  return 0;
 }
 
 void AsanDumpProcessMap() {
@@ -271,7 +271,7 @@ int GetPid() {
   return GetProcessId(GetCurrentProcess());
 }
 
-uintptr_t GetThreadSelf() {
+uptr GetThreadSelf() {
   return GetCurrentThreadId();
 }
 
@@ -308,7 +308,7 @@ int Atexit(void (*function)(void)) {
   return atexit(function);
 }
 
-void SortArray(uintptr_t *array, size_t size) {
+void SortArray(uptr *array, size_t size) {
   std::sort(array, array + size);
 }
 
diff --git a/compiler-rt/lib/asan/tests/asan_noinst_test.cc b/compiler-rt/lib/asan/tests/asan_noinst_test.cc
index 204c0dacc34..da5b678bfd0 100644
--- a/compiler-rt/lib/asan/tests/asan_noinst_test.cc
+++ b/compiler-rt/lib/asan/tests/asan_noinst_test.cc
@@ -92,11 +92,11 @@ TEST(AddressSanitizer, NoInstMallocTest) {
 #endif
 }
 
-static void PrintShadow(const char *tag, uintptr_t ptr, size_t size) {
+static void PrintShadow(const char *tag, uptr ptr, size_t size) {
   fprintf(stderr, "%s shadow: %lx size % 3ld: ", tag, (long)ptr, (long)size);
-  uintptr_t prev_shadow = 0;
+  uptr prev_shadow = 0;
   for (intptr_t i = -32; i < (intptr_t)size + 32; i++) {
-    uintptr_t shadow = __asan::MemToShadow(ptr + i);
+    uptr shadow = __asan::MemToShadow(ptr + i);
     if (i == 0 || i == (intptr_t)size)
       fprintf(stderr, ".");
     if (shadow != prev_shadow) {
@@ -110,13 +110,13 @@ static void PrintShadow(const char *tag, uintptr_t ptr, size_t size) {
 TEST(AddressSanitizer, DISABLED_InternalPrintShadow) {
   for (size_t size = 1; size <= 513; size++) {
     char *ptr = new char[size];
-    PrintShadow("m", (uintptr_t)ptr, size);
+    PrintShadow("m", (uptr)ptr, size);
     delete [] ptr;
-    PrintShadow("f", (uintptr_t)ptr, size);
+    PrintShadow("f", (uptr)ptr, size);
   }
 }
 
-static uintptr_t pc_array[] = {
+static uptr pc_array[] = {
 #if __WORDSIZE == 64
   0x7effbf756068ULL,
   0x7effbf75e5abULL,
@@ -215,7 +215,7 @@ void CompressStackTraceTest(size_t n_iter) {
     std::random_shuffle(pc_array, pc_array + kNumPcs);
     __asan::AsanStackTrace stack0, stack1;
     stack0.CopyFrom(pc_array, kNumPcs);
-    stack0.size = std::max((size_t)1, (size_t)my_rand(&seed) % stack0.size);
+    stack0.size = std::max((size_t)1, (size_t)(my_rand(&seed) % stack0.size));
     size_t compress_size =
       std::max((size_t)2, (size_t)my_rand(&seed) % (2 * kNumPcs));
     size_t n_frames =