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 template <typename AddressSpaceView>
  58 using ByteMapASVT =
  59     TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
  60
  61 template <typename AddressSpaceViewTy>
  62 struct AP32 {
  63   static const uptr kSpaceBeg = 0;
  64   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
  65   static const uptr kMetadataSize = sizeof(ChunkMetadata);
  66   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
  67   static const uptr kRegionSizeLog = __lsan::kRegionSizeLog;
  68   using AddressSpaceView = AddressSpaceViewTy;
  69   using ByteMap = __lsan::ByteMapASVT<AddressSpaceView>;
  70   typedef NoOpMapUnmapCallback MapUnmapCallback;
  71   static const uptr kFlags = 0;
  72 };
  73 template <typename AddressSpaceView>
  74 using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
  75 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
  76 #elif defined(__x86_64__) || defined(__powerpc64__)
  77 # if defined(__powerpc64__)
  78 const uptr kAllocatorSpace = 0xa0000000000ULL;
  79 const uptr kAllocatorSize  = 0x20000000000ULL;  // 2T.
  80 # else
  81 const uptr kAllocatorSpace = 0x600000000000ULL;
  82 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.
  83 # endif
  84 template <typename AddressSpaceViewTy>
  85 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
  86   static const uptr kSpaceBeg = kAllocatorSpace;
  87   static const uptr kSpaceSize = kAllocatorSize;
  88   static const uptr kMetadataSize = sizeof(ChunkMetadata);
  89   typedef DefaultSizeClassMap SizeClassMap;
  90   typedef NoOpMapUnmapCallback MapUnmapCallback;
  91   static const uptr kFlags = 0;
  92   using AddressSpaceView = AddressSpaceViewTy;
  93 };
  94
  95 template <typename AddressSpaceView>
  96 using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
  97 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
  98 #endif
  99
 100 template <typename AddressSpaceView>
 101 using AllocatorCacheASVT =
 102     SizeClassAllocatorLocalCache<PrimaryAllocatorASVT<AddressSpaceView>>;
 103 using AllocatorCache = AllocatorCacheASVT<LocalAddressSpaceView>;
 104
 105 template <typename AddressSpaceView>
 106 using SecondaryAllocatorASVT =
 107     LargeMmapAllocator<NoOpMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray,
 108                        AddressSpaceView>;
 109
 110 template <typename AddressSpaceView>
 111 using AllocatorASVT =
 112     CombinedAllocator<PrimaryAllocatorASVT<AddressSpaceView>,
 113                       AllocatorCacheASVT<AddressSpaceView>,
 114                       SecondaryAllocatorASVT<AddressSpaceView>>;
 115 using Allocator = AllocatorASVT<LocalAddressSpaceView>;
 116
 117 AllocatorCache *GetAllocatorCache();
 118
 119 int lsan_posix_memalign(void **memptr, uptr alignment, uptr size,
 120                         const StackTrace &stack);
 121 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack);
 122 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack);
 123 void *lsan_malloc(uptr size, const StackTrace &stack);
 124 void lsan_free(void *p);
 125 void *lsan_realloc(void *p, uptr size, const StackTrace &stack);
 126 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack);
 127 void *lsan_valloc(uptr size, const StackTrace &stack);
 128 void *lsan_pvalloc(uptr size, const StackTrace &stack);
 129 uptr lsan_mz_size(const void *p);
 130
 131 }  // namespace __lsan
 132
 133 #endif  // LSAN_ALLOCATOR_H