tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

Alloc.c (10005B)

      1 /* Alloc.c -- Memory allocation functions
      2 2018-04-27 : Igor Pavlov : Public domain */
      3 
      4 #include "Precomp.h"
      5 
      6 #include <stdio.h>
      7 
      8 #ifdef _WIN32
      9 #include <windows.h>
     10 #endif
     11 #include <stdlib.h>
     12 
     13 #include "Alloc.h"
     14 
     15 /* #define _SZ_ALLOC_DEBUG */
     16 
     17 /* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
     18 #ifdef _SZ_ALLOC_DEBUG
     19 
     20 #include <stdio.h>
     21 int g_allocCount = 0;
     22 int g_allocCountMid = 0;
     23 int g_allocCountBig = 0;
     24 
     25 
     26 #define CONVERT_INT_TO_STR(charType, tempSize) \
     27  unsigned char temp[tempSize]; unsigned i = 0; \
     28  while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
     29  *s++ = (charType)('0' + (unsigned)val); \
     30  while (i != 0) { i--; *s++ = temp[i]; } \
     31  *s = 0;
     32 
     33 static void ConvertUInt64ToString(UInt64 val, char *s)
     34 {
     35  CONVERT_INT_TO_STR(char, 24);
     36 }
     37 
     38 #define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
     39 
     40 static void ConvertUInt64ToHex(UInt64 val, char *s)
     41 {
     42  UInt64 v = val;
     43  unsigned i;
     44  for (i = 1;; i++)
     45  {
     46    v >>= 4;
     47    if (v == 0)
     48      break;
     49  }
     50  s[i] = 0;
     51  do
     52  {
     53    unsigned t = (unsigned)(val & 0xF);
     54    val >>= 4;
     55    s[--i] = GET_HEX_CHAR(t);
     56  }
     57  while (i);
     58 }
     59 
     60 #define DEBUG_OUT_STREAM stderr
     61 
     62 static void Print(const char *s)
     63 {
     64  fputs(s, DEBUG_OUT_STREAM);
     65 }
     66 
     67 static void PrintAligned(const char *s, size_t align)
     68 {
     69  size_t len = strlen(s);
     70  for(;;)
     71  {
     72    fputc(' ', DEBUG_OUT_STREAM);
     73    if (len >= align)
     74      break;
     75    ++len;
     76  }
     77  Print(s);
     78 }
     79 
     80 static void PrintLn()
     81 {
     82  Print("\n");
     83 }
     84 
     85 static void PrintHex(UInt64 v, size_t align)
     86 {
     87  char s[32];
     88  ConvertUInt64ToHex(v, s);
     89  PrintAligned(s, align);
     90 }
     91 
     92 static void PrintDec(UInt64 v, size_t align)
     93 {
     94  char s[32];
     95  ConvertUInt64ToString(v, s);
     96  PrintAligned(s, align);
     97 }
     98 
     99 static void PrintAddr(void *p)
    100 {
    101  PrintHex((UInt64)(size_t)(ptrdiff_t)p, 12);
    102 }
    103 
    104 
    105 #define PRINT_ALLOC(name, cnt, size, ptr) \
    106    Print(name " "); \
    107    PrintDec(cnt++, 10); \
    108    PrintHex(size, 10); \
    109    PrintAddr(ptr); \
    110    PrintLn();
    111 
    112 #define PRINT_FREE(name, cnt, ptr) if (ptr) { \
    113    Print(name " "); \
    114    PrintDec(--cnt, 10); \
    115    PrintAddr(ptr); \
    116    PrintLn(); }
    117 
    118 #else
    119 
    120 #define PRINT_ALLOC(name, cnt, size, ptr)
    121 #define PRINT_FREE(name, cnt, ptr)
    122 #define Print(s)
    123 #define PrintLn()
    124 #define PrintHex(v, align)
    125 #define PrintDec(v, align)
    126 #define PrintAddr(p)
    127 
    128 #endif
    129 
    130 
    131 
    132 void *MyAlloc(size_t size)
    133 {
    134  if (size == 0)
    135    return NULL;
    136  #ifdef _SZ_ALLOC_DEBUG
    137  {
    138    void *p = malloc(size);
    139    PRINT_ALLOC("Alloc    ", g_allocCount, size, p);
    140    return p;
    141  }
    142  #else
    143  return malloc(size);
    144  #endif
    145 }
    146 
    147 void MyFree(void *address)
    148 {
    149  PRINT_FREE("Free    ", g_allocCount, address);
    150  
    151  free(address);
    152 }
    153 
    154 #ifdef _WIN32
    155 
    156 void *MidAlloc(size_t size)
    157 {
    158  if (size == 0)
    159    return NULL;
    160  
    161  PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);
    162  
    163  return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
    164 }
    165 
    166 void MidFree(void *address)
    167 {
    168  PRINT_FREE("Free-Mid", g_allocCountMid, address);
    169 
    170  if (!address)
    171    return;
    172  VirtualFree(address, 0, MEM_RELEASE);
    173 }
    174 
    175 #ifndef MEM_LARGE_PAGES
    176 #undef _7ZIP_LARGE_PAGES
    177 #endif
    178 
    179 #ifdef _7ZIP_LARGE_PAGES
    180 SIZE_T g_LargePageSize = 0;
    181 typedef SIZE_T (WINAPI *GetLargePageMinimumP)();
    182 #endif
    183 
    184 void SetLargePageSize()
    185 {
    186  #ifdef _7ZIP_LARGE_PAGES
    187  SIZE_T size;
    188  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
    189        GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
    190  if (!largePageMinimum)
    191    return;
    192  size = largePageMinimum();
    193  if (size == 0 || (size & (size - 1)) != 0)
    194    return;
    195  g_LargePageSize = size;
    196  #endif
    197 }
    198 
    199 
    200 void *BigAlloc(size_t size)
    201 {
    202  if (size == 0)
    203    return NULL;
    204 
    205  PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);
    206  
    207  #ifdef _7ZIP_LARGE_PAGES
    208  {
    209    SIZE_T ps = g_LargePageSize;
    210    if (ps != 0 && ps <= (1 << 30) && size > (ps / 2))
    211    {
    212      size_t size2;
    213      ps--;
    214      size2 = (size + ps) & ~ps;
    215      if (size2 >= size)
    216      {
    217        void *res = VirtualAlloc(NULL, size2, MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
    218        if (res)
    219          return res;
    220      }
    221    }
    222  }
    223  #endif
    224 
    225  return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
    226 }
    227 
    228 void BigFree(void *address)
    229 {
    230  PRINT_FREE("Free-Big", g_allocCountBig, address);
    231  
    232  if (!address)
    233    return;
    234  VirtualFree(address, 0, MEM_RELEASE);
    235 }
    236 
    237 #endif
    238 
    239 
    240 static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MyAlloc(size); }
    241 static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MyFree(address); }
    242 const ISzAlloc g_Alloc = { SzAlloc, SzFree };
    243 
    244 static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MidAlloc(size); }
    245 static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MidFree(address); }
    246 const ISzAlloc g_MidAlloc = { SzMidAlloc, SzMidFree };
    247 
    248 static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return BigAlloc(size); }
    249 static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); BigFree(address); }
    250 const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
    251 
    252 
    253 /*
    254  uintptr_t : <stdint.h> C99 (optional)
    255            : unsupported in VS6
    256 */
    257 
    258 #ifdef _WIN32
    259  typedef UINT_PTR UIntPtr;
    260 #else
    261  /*
    262  typedef uintptr_t UIntPtr;
    263  */
    264  typedef ptrdiff_t UIntPtr;
    265 #endif
    266 
    267 
    268 #define ADJUST_ALLOC_SIZE 0
    269 /*
    270 #define ADJUST_ALLOC_SIZE (sizeof(void *) - 1)
    271 */
    272 /*
    273  Use (ADJUST_ALLOC_SIZE = (sizeof(void *) - 1)), if
    274     MyAlloc() can return address that is NOT multiple of sizeof(void *).
    275 */
    276 
    277 
    278 /*
    279 #define MY_ALIGN_PTR_DOWN(p, align) ((void *)((char *)(p) - ((size_t)(UIntPtr)(p) & ((align) - 1))))
    280 */
    281 #define MY_ALIGN_PTR_DOWN(p, align) ((void *)((((UIntPtr)(p)) & ~((UIntPtr)(align) - 1))))
    282 
    283 #define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
    284 
    285 
    286 #if (_POSIX_C_SOURCE >= 200112L) && !defined(_WIN32)
    287  #define USE_posix_memalign
    288 #endif
    289 
    290 /*
    291  This posix_memalign() is for test purposes only.
    292  We also need special Free() function instead of free(),
    293  if this posix_memalign() is used.
    294 */
    295 
    296 /*
    297 static int posix_memalign(void **ptr, size_t align, size_t size)
    298 {
    299  size_t newSize = size + align;
    300  void *p;
    301  void *pAligned;
    302  *ptr = NULL;
    303  if (newSize < size)
    304    return 12; // ENOMEM
    305  p = MyAlloc(newSize);
    306  if (!p)
    307    return 12; // ENOMEM
    308  pAligned = MY_ALIGN_PTR_UP_PLUS(p, align);
    309  ((void **)pAligned)[-1] = p;
    310  *ptr = pAligned;
    311  return 0;
    312 }
    313 */
    314 
    315 /*
    316  ALLOC_ALIGN_SIZE >= sizeof(void *)
    317  ALLOC_ALIGN_SIZE >= cache_line_size
    318 */
    319 
    320 #define ALLOC_ALIGN_SIZE ((size_t)1 << 7)
    321 
    322 static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
    323 {
    324  #ifndef USE_posix_memalign
    325  
    326  void *p;
    327  void *pAligned;
    328  size_t newSize;
    329  UNUSED_VAR(pp);
    330 
    331  /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
    332     block to prevent cache line sharing with another allocated blocks */
    333 
    334  newSize = size + ALLOC_ALIGN_SIZE * 1 + ADJUST_ALLOC_SIZE;
    335  if (newSize < size)
    336    return NULL;
    337 
    338  p = MyAlloc(newSize);
    339  
    340  if (!p)
    341    return NULL;
    342  pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
    343 
    344  Print(" size="); PrintHex(size, 8);
    345  Print(" a_size="); PrintHex(newSize, 8);
    346  Print(" ptr="); PrintAddr(p);
    347  Print(" a_ptr="); PrintAddr(pAligned);
    348  PrintLn();
    349 
    350  ((void **)pAligned)[-1] = p;
    351 
    352  return pAligned;
    353 
    354  #else
    355 
    356  void *p;
    357  UNUSED_VAR(pp);
    358  if (posix_memalign(&p, ALLOC_ALIGN_SIZE, size))
    359    return NULL;
    360 
    361  Print(" posix_memalign="); PrintAddr(p);
    362  PrintLn();
    363 
    364  return p;
    365 
    366  #endif
    367 }
    368 
    369 
    370 static void SzAlignedFree(ISzAllocPtr pp, void *address)
    371 {
    372  UNUSED_VAR(pp);
    373  #ifndef USE_posix_memalign
    374  if (address)
    375    MyFree(((void **)address)[-1]);
    376  #else
    377  free(address);
    378  #endif
    379 }
    380 
    381 
    382 const ISzAlloc g_AlignedAlloc = { SzAlignedAlloc, SzAlignedFree };
    383 
    384 
    385 
    386 #define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))
    387 
    388 /* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
    389 #define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
    390 /*
    391 #define REAL_BLOCK_PTR_VAR(p) ((void **)(p))[-1]
    392 */
    393 
    394 static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
    395 {
    396  CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
    397  void *adr;
    398  void *pAligned;
    399  size_t newSize;
    400  size_t extra;
    401  size_t alignSize = (size_t)1 << p->numAlignBits;
    402 
    403  if (alignSize < sizeof(void *))
    404    alignSize = sizeof(void *);
    405  
    406  if (p->offset >= alignSize)
    407    return NULL;
    408 
    409  /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
    410     block to prevent cache line sharing with another allocated blocks */
    411  extra = p->offset & (sizeof(void *) - 1);
    412  newSize = size + alignSize + extra + ADJUST_ALLOC_SIZE;
    413  if (newSize < size)
    414    return NULL;
    415 
    416  adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
    417  
    418  if (!adr)
    419    return NULL;
    420 
    421  pAligned = (char *)MY_ALIGN_PTR_DOWN((char *)adr +
    422      alignSize - p->offset + extra + ADJUST_ALLOC_SIZE, alignSize) + p->offset;
    423 
    424  PrintLn();
    425  Print("- Aligned: ");
    426  Print(" size="); PrintHex(size, 8);
    427  Print(" a_size="); PrintHex(newSize, 8);
    428  Print(" ptr="); PrintAddr(adr);
    429  Print(" a_ptr="); PrintAddr(pAligned);
    430  PrintLn();
    431 
    432  REAL_BLOCK_PTR_VAR(pAligned) = adr;
    433 
    434  return pAligned;
    435 }
    436 
    437 
    438 static void AlignOffsetAlloc_Free(ISzAllocPtr pp, void *address)
    439 {
    440  if (address)
    441  {
    442    CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
    443    PrintLn();
    444    Print("- Aligned Free: ");
    445    PrintLn();
    446    ISzAlloc_Free(p->baseAlloc, REAL_BLOCK_PTR_VAR(address));
    447  }
    448 }
    449 
    450 
    451 void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p)
    452 {
    453  p->vt.Alloc = AlignOffsetAlloc_Alloc;
    454  p->vt.Free = AlignOffsetAlloc_Free;
    455 }