base/allocator/win_allocator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This is a simple allocator based on the windows heap.
   6
   7 extern "C" {
   8
   9 HANDLE win_heap;
  10
  11 bool win_heap_init(bool use_lfh) {
  12   win_heap = HeapCreate(0, 0, 0);
  13   if (win_heap == NULL)
  14     return false;
  15
  16   if (use_lfh) {
  17     ULONG enable_lfh = 2;
  18     HeapSetInformation(win_heap, HeapCompatibilityInformation,
  19                        &enable_lfh, sizeof(enable_lfh));
  20     // NOTE: Setting LFH may fail.  Vista already has it enabled.
  21     //       And under the debugger, it won't use LFH.  So we
  22     //       ignore any errors.
  23   }
  24
  25   return true;
  26 }
  27
  28 void* win_heap_malloc(size_t size) {
  29   return HeapAlloc(win_heap, 0, size);
  30 }
  31
  32 void win_heap_free(void* size) {
  33   HeapFree(win_heap, 0, size);
  34 }
  35
  36 void* win_heap_realloc(void* ptr, size_t size) {
  37   if (!ptr)
  38     return win_heap_malloc(size);
  39   if (!size) {
  40     win_heap_free(ptr);
  41     return NULL;
  42   }
  43   return HeapReAlloc(win_heap, 0, ptr, size);
  44 }
  45
  46 size_t win_heap_msize(void* ptr) {
  47   return HeapSize(win_heap, 0, ptr);
  48 }
  49
  50 void* win_heap_memalign(size_t alignment, size_t size) {
  51   // Reserve enough space to ensure we can align and set aligned_ptr[-1] to the
  52   // original allocation for use with win_heap_memalign_free() later.
  53   size_t allocation_size = size + (alignment - 1) + sizeof(void*);
  54
  55   // Check for overflow.  Alignment and size are checked in allocator_shim.
  56   DCHECK_LT(size, allocation_size);
  57   DCHECK_LT(alignment, allocation_size);
  58
  59   // Since we're directly calling the allocator function, before OOM handling,
  60   // we need to NULL check to ensure the allocation succeeded.
  61   void* ptr = win_heap_malloc(allocation_size);
  62   if (!ptr)
  63     return ptr;
  64
  65   char* aligned_ptr = static_cast<char*>(ptr) + sizeof(void*);
  66   aligned_ptr +=
  67       alignment - reinterpret_cast<uintptr_t>(aligned_ptr) & (alignment - 1);
  68
  69   reinterpret_cast<void**>(aligned_ptr)[-1] = ptr;
  70   return aligned_ptr;
  71 }
  72
  73 void win_heap_memalign_free(void* ptr) {
  74   if (ptr)
  75     win_heap_free(static_cast<void**>(ptr)[-1]);
  76 }
  77
  78 }  // extern "C"