[llvm-commits] [compiler-rt] r157746 - in /compiler-rt/trunk/lib/asan: ./ tests/
Kostya Serebryany
kcc at google.com
Thu May 31 07:35:54 PDT 2012
Author: kcc
Date: Thu May 31 09:35:53 2012
New Revision: 157746
URL: http://llvm.org/viewvc/llvm-project?rev=157746&view=rev
Log:
[asan] more renaming
Modified:
compiler-rt/trunk/lib/asan/asan_allocator.cc
compiler-rt/trunk/lib/asan/asan_allocator.h
compiler-rt/trunk/lib/asan/asan_globals.cc
compiler-rt/trunk/lib/asan/asan_interceptors.cc
compiler-rt/trunk/lib/asan/asan_interceptors.h
compiler-rt/trunk/lib/asan/asan_interface.h
compiler-rt/trunk/lib/asan/asan_internal.h
compiler-rt/trunk/lib/asan/asan_linux.cc
compiler-rt/trunk/lib/asan/asan_lock.h
compiler-rt/trunk/lib/asan/asan_mac.cc
compiler-rt/trunk/lib/asan/asan_malloc_linux.cc
compiler-rt/trunk/lib/asan/asan_malloc_mac.cc
compiler-rt/trunk/lib/asan/asan_malloc_win.cc
compiler-rt/trunk/lib/asan/asan_mapping.h
compiler-rt/trunk/lib/asan/asan_poisoning.cc
compiler-rt/trunk/lib/asan/asan_posix.cc
compiler-rt/trunk/lib/asan/asan_printf.cc
compiler-rt/trunk/lib/asan/asan_procmaps.h
compiler-rt/trunk/lib/asan/asan_rtl.cc
compiler-rt/trunk/lib/asan/asan_stack.cc
compiler-rt/trunk/lib/asan/asan_stack.h
compiler-rt/trunk/lib/asan/asan_stats.cc
compiler-rt/trunk/lib/asan/asan_stats.h
compiler-rt/trunk/lib/asan/asan_thread.cc
compiler-rt/trunk/lib/asan/asan_thread.h
compiler-rt/trunk/lib/asan/asan_thread_registry.cc
compiler-rt/trunk/lib/asan/asan_thread_registry.h
compiler-rt/trunk/lib/asan/asan_win.cc
compiler-rt/trunk/lib/asan/tests/asan_noinst_test.cc
Modified: compiler-rt/trunk/lib/asan/asan_allocator.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_allocator.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_allocator.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_allocator.cc Thu May 31 09:35:53 2012
@@ -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 @@
#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 @@
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 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
};
-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::Push(AsanChunk *n) {
- CHECK(n->next == NULL);
+ CHECK(n->next == 0);
if (last_) {
CHECK(first_);
CHECK(!last_->next);
@@ -281,8 +281,8 @@
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 @@
// 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 @@
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 @@
}
}
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 @@
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 @@
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 @@
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 @@
}
}
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
}
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 @@
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 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 @@
}
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 @@
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 @@
// 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 @@
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 @@
}
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 @@
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 @@
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 @@
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 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// ---------------------- 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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
// ---------------------- 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 @@
}
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;
Modified: compiler-rt/trunk/lib/asan/asan_allocator.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_allocator.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_allocator.h (original)
+++ compiler-rt/trunk/lib/asan/asan_allocator.h Thu May 31 09:35:53 2012
@@ -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 @@
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 @@
// 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 @@
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
Modified: compiler-rt/trunk/lib/asan/asan_globals.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_globals.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_globals.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_globals.cc Thu May 31 09:35:53 2012
@@ -36,10 +36,10 @@
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 @@
}
}
-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 DescribeAddrIfGlobal(uintptr_t addr) {
+bool DescribeAddrIfGlobal(uptr addr) {
if (!FLAG_report_globals) return false;
ScopedLock lock(&mu_for_globals);
bool res = false;
Modified: compiler-rt/trunk/lib/asan/asan_interceptors.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_interceptors.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_interceptors.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_interceptors.cc Thu May 31 09:35:53 2012
@@ -61,27 +61,27 @@
# 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 @@
// 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 @@
// 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 @@
// 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 @@
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_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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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(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 @@
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 @@
}
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*, 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 @@
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 @@
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 @@
}
#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 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 @@
}
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 @@
}
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 @@
}
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 @@
#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);
Modified: compiler-rt/trunk/lib/asan/asan_interceptors.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_interceptors.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_interceptors.h (original)
+++ compiler-rt/trunk/lib/asan/asan_interceptors.h Thu May 31 09:35:53 2012
@@ -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 @@
// __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);
Modified: compiler-rt/trunk/lib/asan/asan_interface.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_interface.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_interface.h (original)
+++ compiler-rt/trunk/lib/asan/asan_interface.h Thu May 31 09:35:53 2012
@@ -112,7 +112,7 @@
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 @@
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.
Modified: compiler-rt/trunk/lib/asan/asan_internal.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_internal.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_internal.h (original)
+++ compiler-rt/trunk/lib/asan/asan_internal.h Thu May 31 09:35:53 2012
@@ -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 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 @@
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 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 @@
// 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 @@
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 @@
# 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 @@
#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 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 @@
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_;
Modified: compiler-rt/trunk/lib/asan/asan_linux.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_linux.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_linux.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_linux.cc Thu May 31 09:35:53 2012
@@ -39,14 +39,14 @@
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 @@
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 @@
# 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 @@
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 @@
}
}
-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 @@
// 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 @@
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 @@
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 @@
}
// 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 @@
// 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 @@
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 @@
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 @@
#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 @@
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) {
Modified: compiler-rt/trunk/lib/asan/asan_lock.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_lock.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_lock.h (original)
+++ compiler-rt/trunk/lib/asan/asan_lock.h Thu May 31 09:35:53 2012
@@ -30,8 +30,8 @@
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 {
Modified: compiler-rt/trunk/lib/asan/asan_mac.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_mac.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_mac.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_mac.cc Thu May 31 09:35:53 2012
@@ -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 @@
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 @@
// No-op. Mac does not support static linkage anyway.
void *AsanDoesNotSupportStaticLinkage() {
- return NULL;
+ return 0;
}
bool AsanInterceptsSignal(int signum) {
@@ -117,14 +117,14 @@
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 @@
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 @@
}
environ++;
}
- return NULL;
+ return 0;
}
size_t AsanRead(int fd, void *buf, size_t count) {
@@ -200,7 +200,7 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
}
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 @@
// 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;
Modified: compiler-rt/trunk/lib/asan/asan_malloc_linux.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_malloc_linux.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_malloc_linux.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_malloc_linux.cc Thu May 31 09:35:53 2012
@@ -73,7 +73,7 @@
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];
Modified: compiler-rt/trunk/lib/asan/asan_malloc_mac.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_malloc_mac.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_malloc_mac.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_malloc_mac.cc Thu May 31 09:35:53 2012
@@ -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 @@
}
// 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 @@
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 @@
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 @@
GET_STACK_TRACE_HERE_FOR_FREE(ptr);
stack.PrintStack();
ShowStatsAndAbort();
- return NULL; // unreachable
+ return 0; // unreachable
}
}
}
@@ -220,7 +220,7 @@
GET_STACK_TRACE_HERE_FOR_FREE(ptr);
stack.PrintStack();
ShowStatsAndAbort();
- return NULL; // unreachable
+ return 0; // unreachable
}
}
}
@@ -337,8 +337,8 @@
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 @@
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);
Modified: compiler-rt/trunk/lib/asan/asan_malloc_win.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_malloc_win.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_malloc_win.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_malloc_win.cc Thu May 31 09:35:53 2012
@@ -71,7 +71,7 @@
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 @@
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);
}
Modified: compiler-rt/trunk/lib/asan/asan_mapping.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_mapping.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_mapping.h (original)
+++ compiler-rt/trunk/lib/asan/asan_mapping.h Thu May 31 09:35:53 2012
@@ -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 @@
#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 @@
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) {
Modified: compiler-rt/trunk/lib/asan/asan_poisoning.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_poisoning.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_poisoning.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_poisoning.cc Thu May 31 09:35:53 2012
@@ -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 @@
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 @@
// 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_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 @@
}
bool __asan_address_is_poisoned(void const volatile *addr) {
- return __asan::AddressIsPoisoned((uintptr_t)addr);
+ return __asan::AddressIsPoisoned((uptr)addr);
}
Modified: compiler-rt/trunk/lib/asan/asan_posix.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_posix.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_posix.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_posix.cc Thu May 31 09:35:53 2012
@@ -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 @@
// 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 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 @@
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 @@
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 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 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 @@
return getpid();
}
-uintptr_t GetThreadSelf() {
- return (uintptr_t)pthread_self();
+uptr GetThreadSelf() {
+ return (uptr)pthread_self();
}
void SleepForSeconds(int seconds) {
@@ -189,7 +189,7 @@
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);
}
Modified: compiler-rt/trunk/lib/asan/asan_printf.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_printf.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_printf.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_printf.cc Thu May 31 09:35:53 2012
@@ -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 @@
// "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 @@
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 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 @@
: 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 @@
// 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);
Modified: compiler-rt/trunk/lib/asan/asan_procmaps.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_procmaps.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_procmaps.h (original)
+++ compiler-rt/trunk/lib/asan/asan_procmaps.h Thu May 31 09:35:53 2012
@@ -21,22 +21,22 @@
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 @@
#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_;
Modified: compiler-rt/trunk/lib/asan/asan_rtl.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_rtl.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_rtl.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_rtl.cc Thu May 31 09:35:53 2012
@@ -26,13 +26,13 @@
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 @@
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 @@
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 @@
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 @@
}
// ---------------------- 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 @@
}
// 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 @@
}
// ---------------------- 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 @@
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 @@
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 @@
// 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 @@
__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 @@
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 @@
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 @@
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 @@
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);
}
Modified: compiler-rt/trunk/lib/asan/asan_stack.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_stack.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_stack.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_stack.cc Thu May 31 09:35:53 2012
@@ -27,9 +27,9 @@
// ----------------------- 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 @@
}
#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 @@
}
#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 @@
// 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 @@
} 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;
Modified: compiler-rt/trunk/lib/asan/asan_stack.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_stack.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_stack.h (original)
+++ compiler-rt/trunk/lib/asan/asan_stack.h Thu May 31 09:35:53 2012
@@ -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 @@
// 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.
Modified: compiler-rt/trunk/lib/asan/asan_stats.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_stats.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_stats.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_stats.cc Thu May 31 09:35:53 2012
@@ -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]);
}
Modified: compiler-rt/trunk/lib/asan/asan_stats.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_stats.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_stats.h (original)
+++ compiler-rt/trunk/lib/asan/asan_stats.h Thu May 31 09:35:53 2012
@@ -23,27 +23,27 @@
// 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];
+ // 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];
- size_t malloc_large;
- size_t malloc_small_slow;
+ uptr malloc_large;
+ uptr malloc_small_slow;
// Ctor for global AsanStats (accumulated stats and main thread stats).
explicit AsanStats(LinkerInitialized) { }
Modified: compiler-rt/trunk/lib/asan/asan_thread.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_thread.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_thread.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_thread.cc Thu May 31 09:35:53 2012
@@ -28,7 +28,7 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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];
}
Modified: compiler-rt/trunk/lib/asan/asan_thread.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_thread.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_thread.h (original)
+++ compiler-rt/trunk/lib/asan/asan_thread.h Thu May 31 09:35:53 2012
@@ -70,16 +70,16 @@
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 @@
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_;
Modified: compiler-rt/trunk/lib/asan/asan_thread_registry.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_thread_registry.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_thread_registry.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_thread_registry.cc Thu May 31 09:35:53 2012
@@ -48,7 +48,7 @@
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 @@
FlushToAccumulatedStatsUnlocked(&thread->stats());
AsanThreadSummary *summary = thread->summary();
CHECK(summary);
- summary->set_thread(NULL);
+ summary->set_thread(0);
}
AsanThread *AsanThreadRegistry::GetMain() {
@@ -74,7 +74,7 @@
// 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 @@
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 @@
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 @@
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;
}
Modified: compiler-rt/trunk/lib/asan/asan_thread_registry.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_thread_registry.h?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_thread_registry.h (original)
+++ compiler-rt/trunk/lib/asan/asan_thread_registry.h Thu May 31 09:35:53 2012
@@ -34,7 +34,7 @@
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 @@
}
// 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();
Modified: compiler-rt/trunk/lib/asan/asan_win.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_win.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_win.cc (original)
+++ compiler-rt/trunk/lib/asan/asan_win.cc Thu May 31 09:35:53 2012
@@ -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 @@
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 @@
// 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 @@
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 @@
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 @@
// ---------------------- 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 @@
#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 @@
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 @@
return GetProcessId(GetCurrentProcess());
}
-uintptr_t GetThreadSelf() {
+uptr GetThreadSelf() {
return GetCurrentThreadId();
}
@@ -308,7 +308,7 @@
return atexit(function);
}
-void SortArray(uintptr_t *array, size_t size) {
+void SortArray(uptr *array, size_t size) {
std::sort(array, array + size);
}
Modified: compiler-rt/trunk/lib/asan/tests/asan_noinst_test.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/tests/asan_noinst_test.cc?rev=157746&r1=157745&r2=157746&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/tests/asan_noinst_test.cc (original)
+++ compiler-rt/trunk/lib/asan/tests/asan_noinst_test.cc Thu May 31 09:35:53 2012
@@ -92,11 +92,11 @@
#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 @@
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 @@
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 =
More information about the llvm-commits
mailing list