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
7extern "C" {
8
9HANDLE win_heap;
10
11bool 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
28void* win_heap_malloc(size_t size) {
29  return HeapAlloc(win_heap, 0, size);
30}
31
32void win_heap_free(void* size) {
33  HeapFree(win_heap, 0, size);
34}
35
36void* 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
46size_t win_heap_msize(void* ptr) {
47  return HeapSize(win_heap, 0, ptr);
48}
49
50void* 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
73void win_heap_memalign_free(void* ptr) {
74  if (ptr)
75    win_heap_free(static_cast<void**>(ptr)[-1]);
76}
77
78}  // extern "C"
79