contrib/compiler-rt/lib/lsan/lsan_allocator.h

   1 //=-- lsan_allocator.h ----------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of LeakSanitizer.
  11 // Allocator for standalone LSan.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LSAN_ALLOCATOR_H
  16 #define LSAN_ALLOCATOR_H
  17
  18 #include "sanitizer_common/sanitizer_allocator.h"
  19 #include "sanitizer_common/sanitizer_common.h"
  20 #include "sanitizer_common/sanitizer_internal_defs.h"
  21 #include "lsan_common.h"
  22
  23 namespace __lsan {
  24
  25 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
  26                bool cleared);
  27 void Deallocate(void *p);
  28 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
  29                  uptr alignment);
  30 uptr GetMallocUsableSize(const void *p);
  31
  32 template<typename Callable>
  33 void ForEachChunk(const Callable &callback);
  34
  35 void GetAllocatorCacheRange(uptr *begin, uptr *end);
  36 void AllocatorThreadFinish();
  37 void InitializeAllocator();
  38
  39 const bool kAlwaysClearMemory = true;
  40
  41 struct ChunkMetadata {
  42   u8 allocated : 8;  // Must be first.
  43   ChunkTag tag : 2;
  44 #if SANITIZER_WORDSIZE == 64
  45   uptr requested_size : 54;
  46 #else
  47   uptr requested_size : 32;
  48   uptr padding : 22;
  49 #endif
  50   u32 stack_trace_id;
  51 };
  52
  53 #if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
  54     defined(__arm__)
  55 static const uptr kRegionSizeLog = 20;
  56 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
  57 typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
  58
  59 struct AP32 {
  60   static const uptr kSpaceBeg = 0;
  61   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
  62   static const uptr kMetadataSize = sizeof(ChunkMetadata);
  63   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
  64   static const uptr kRegionSizeLog = __lsan::kRegionSizeLog;
  65   typedef __lsan::ByteMap ByteMap;
  66   typedef NoOpMapUnmapCallback MapUnmapCallback;
  67   static const uptr kFlags = 0;
  68 };
  69 typedef SizeClassAllocator32<AP32> PrimaryAllocator;
  70 #elif defined(__x86_64__) || defined(__powerpc64__)
  71 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
  72   static const uptr kSpaceBeg = 0x600000000000ULL;
  73   static const uptr kSpaceSize =  0x40000000000ULL; // 4T.
  74   static const uptr kMetadataSize = sizeof(ChunkMetadata);
  75   typedef DefaultSizeClassMap SizeClassMap;
  76   typedef NoOpMapUnmapCallback MapUnmapCallback;
  77   static const uptr kFlags = 0;
  78 };
  79
  80 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
  81 #endif
  82 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
  83
  84 AllocatorCache *GetAllocatorCache();
  85
  86 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack);
  87 void *lsan_malloc(uptr size, const StackTrace &stack);
  88 void lsan_free(void *p);
  89 void *lsan_realloc(void *p, uptr size, const StackTrace &stack);
  90 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack);
  91 void *lsan_valloc(uptr size, const StackTrace &stack);
  92 uptr lsan_mz_size(const void *p);
  93
  94 }  // namespace __lsan
  95
  96 #endif  // LSAN_ALLOCATOR_H