Lines Matching refs:Ptr
73 static INLINE AtomicPackedHeader *getAtomicHeader(void *Ptr) {
74 return reinterpret_cast<AtomicPackedHeader *>(reinterpret_cast<uptr>(Ptr) -
78 const AtomicPackedHeader *getConstAtomicHeader(const void *Ptr) {
80 reinterpret_cast<uptr>(Ptr) - getHeaderSize());
83 static INLINE bool isAligned(const void *Ptr) {
84 return IsAligned(reinterpret_cast<uptr>(Ptr), MinAlignment);
90 static INLINE void *getBackendPtr(const void *Ptr, UnpackedHeader *Header) {
91 return reinterpret_cast<void *>(reinterpret_cast<uptr>(Ptr) -
97 static INLINE uptr getUsableSize(const void *Ptr, UnpackedHeader *Header) {
103 getBackendPtr(Ptr, Header)) - getHeaderSize();
107 static INLINE uptr getSize(const void *Ptr, UnpackedHeader *Header) {
112 getBackendPtr(Ptr, Header)) - getHeaderSize() - SizeOrUnusedBytes;
116 static INLINE u16 computeChecksum(const void *Ptr, UnpackedHeader *Header) {
121 const u32 Crc = computeCRC32(Cookie, reinterpret_cast<uptr>(Ptr),
128 static INLINE bool isValid(const void *Ptr) {
130 atomic_load_relaxed(getConstAtomicHeader(Ptr));
134 computeChecksum(Ptr, &NewUnpackedHeader));
143 void loadHeader(const void *Ptr, UnpackedHeader *NewUnpackedHeader) {
145 atomic_load_relaxed(getConstAtomicHeader(Ptr));
148 computeChecksum(Ptr, NewUnpackedHeader)))
149 dieWithMessage("corrupted chunk header at address %p\n", Ptr);
153 static INLINE void storeHeader(void *Ptr, UnpackedHeader *NewUnpackedHeader) {
154 NewUnpackedHeader->Checksum = computeChecksum(Ptr, NewUnpackedHeader);
156 atomic_store_relaxed(getAtomicHeader(Ptr), NewPackedHeader);
162 static INLINE void compareExchangeHeader(void *Ptr,
165 NewUnpackedHeader->Checksum = computeChecksum(Ptr, NewUnpackedHeader);
169 getAtomicHeader(Ptr), &OldPackedHeader, NewPackedHeader,
171 dieWithMessage("race on chunk header at address %p\n", Ptr);
181 void Recycle(void *Ptr) {
183 Chunk::loadHeader(Ptr, &Header);
185 dieWithMessage("invalid chunk state when recycling address %p\n", Ptr);
188 Chunk::compareExchangeHeader(Ptr, &NewHeader, &Header);
189 void *BackendPtr = Chunk::getBackendPtr(Ptr, &Header);
204 void Deallocate(void *Ptr) {
206 getBackend().deallocatePrimary(Cache_, Ptr, BatchClassId);
289 bool isValidPointer(const void *Ptr) {
291 if (UNLIKELY(!Ptr))
293 if (!Chunk::isAligned(Ptr))
295 return Chunk::isValid(Ptr);
307 if (void *Ptr = GuardedAlloc.allocate(Size))
308 return Ptr;
393 void *Ptr = reinterpret_cast<void *>(UserPtr);
394 Chunk::storeHeader(Ptr, &Header);
396 __sanitizer_malloc_hook(Ptr, Size);
397 return Ptr;
403 void quarantineOrDeallocateChunk(void *Ptr, UnpackedHeader *Header,
409 Chunk::compareExchangeHeader(Ptr, &NewHeader, Header);
410 void *BackendPtr = Chunk::getBackendPtr(Ptr, Header);
430 Chunk::compareExchangeHeader(Ptr, &NewHeader, Header);
434 Ptr, EstimatedSize);
442 void deallocate(void *Ptr, uptr DeleteSize, uptr DeleteAlignment,
452 __sanitizer_free_hook(Ptr);
453 if (UNLIKELY(!Ptr))
457 if (UNLIKELY(GuardedAlloc.pointerIsMine(Ptr))) {
458 GuardedAlloc.deallocate(Ptr);
463 if (UNLIKELY(!Chunk::isAligned(Ptr)))
464 dieWithMessage("misaligned pointer when deallocating address %p\n", Ptr);
466 Chunk::loadHeader(Ptr, &Header);
468 dieWithMessage("invalid chunk state when deallocating address %p\n", Ptr);
475 "%p\n", Ptr);
478 const uptr Size = Chunk::getSize(Ptr, &Header);
482 Ptr);
485 quarantineOrDeallocateChunk(Ptr, &Header, Size);
541 uptr getUsableSize(const void *Ptr) {
543 if (UNLIKELY(!Ptr))
547 if (UNLIKELY(GuardedAlloc.pointerIsMine(Ptr)))
548 return GuardedAlloc.getSize(Ptr);
552 Chunk::loadHeader(Ptr, &Header);
555 dieWithMessage("invalid chunk state when sizing address %p\n", Ptr);
556 return Chunk::getUsableSize(Ptr, &Header);
701 void scudoDeallocate(void *Ptr, uptr Size, uptr Alignment, AllocType Type) {
702 Instance.deallocate(Ptr, Size, Alignment, Type);
705 void *scudoRealloc(void *Ptr, uptr Size) {
706 if (!Ptr)
709 Instance.deallocate(Ptr, 0, 0, FromMalloc);
712 return SetErrnoOnNull(Instance.reallocate(Ptr, Size));
743 void *Ptr = Instance.allocate(Size, Alignment, FromMemalign);
744 if (UNLIKELY(!Ptr))
746 *MemPtr = Ptr;
760 uptr scudoMallocUsableSize(void *Ptr) {
761 return Instance.getUsableSize(Ptr);
790 int __sanitizer_get_ownership(const void *Ptr) {
791 return Instance.isValidPointer(Ptr);
794 uptr __sanitizer_get_allocated_size(const void *Ptr) {
795 return Instance.getUsableSize(Ptr);
800 void *Ptr, uptr Size) {
801 (void)Ptr;
805 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_free_hook, void *Ptr) {
806 (void)Ptr;