allocator_shim_default_dispatch_to_winheap.cc 3.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
  1. // Copyright 2016 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. #include "base/allocator/allocator_shim.h"
  5. #include <ostream>
  6. #include "base/allocator/winheap_stubs_win.h"
  7. #include "base/check.h"
  8. namespace {
  9. using base::allocator::AllocatorDispatch;
  10. void* DefaultWinHeapMallocImpl(const AllocatorDispatch*,
  11. size_t size,
  12. void* context) {
  13. return base::allocator::WinHeapMalloc(size);
  14. }
  15. void* DefaultWinHeapCallocImpl(const AllocatorDispatch* self,
  16. size_t n,
  17. size_t elem_size,
  18. void* context) {
  19. // Overflow check.
  20. const size_t size = n * elem_size;
  21. if (elem_size != 0 && size / elem_size != n)
  22. return nullptr;
  23. void* result = DefaultWinHeapMallocImpl(self, size, context);
  24. if (result) {
  25. memset(result, 0, size);
  26. }
  27. return result;
  28. }
  29. void* DefaultWinHeapMemalignImpl(const AllocatorDispatch* self,
  30. size_t alignment,
  31. size_t size,
  32. void* context) {
  33. CHECK(false) << "The windows heap does not support memalign.";
  34. return nullptr;
  35. }
  36. void* DefaultWinHeapReallocImpl(const AllocatorDispatch* self,
  37. void* address,
  38. size_t size,
  39. void* context) {
  40. return base::allocator::WinHeapRealloc(address, size);
  41. }
  42. void DefaultWinHeapFreeImpl(const AllocatorDispatch*,
  43. void* address,
  44. void* context) {
  45. base::allocator::WinHeapFree(address);
  46. }
  47. size_t DefaultWinHeapGetSizeEstimateImpl(const AllocatorDispatch*,
  48. void* address,
  49. void* context) {
  50. return base::allocator::WinHeapGetSizeEstimate(address);
  51. }
  52. void* DefaultWinHeapAlignedMallocImpl(const AllocatorDispatch*,
  53. size_t size,
  54. size_t alignment,
  55. void* context) {
  56. return base::allocator::WinHeapAlignedMalloc(size, alignment);
  57. }
  58. void* DefaultWinHeapAlignedReallocImpl(const AllocatorDispatch*,
  59. void* ptr,
  60. size_t size,
  61. size_t alignment,
  62. void* context) {
  63. return base::allocator::WinHeapAlignedRealloc(ptr, size, alignment);
  64. }
  65. void DefaultWinHeapAlignedFreeImpl(const AllocatorDispatch*,
  66. void* ptr,
  67. void* context) {
  68. base::allocator::WinHeapAlignedFree(ptr);
  69. }
  70. } // namespace
  71. // Guarantee that default_dispatch is compile-time initialized to avoid using
  72. // it before initialization (allocations before main in release builds with
  73. // optimizations disabled).
  74. constexpr AllocatorDispatch AllocatorDispatch::default_dispatch = {
  75. &DefaultWinHeapMallocImpl,
  76. &DefaultWinHeapMallocImpl, /* alloc_unchecked_function */
  77. &DefaultWinHeapCallocImpl,
  78. &DefaultWinHeapMemalignImpl,
  79. &DefaultWinHeapReallocImpl,
  80. &DefaultWinHeapFreeImpl,
  81. &DefaultWinHeapGetSizeEstimateImpl,
  82. nullptr, /* batch_malloc_function */
  83. nullptr, /* batch_free_function */
  84. nullptr, /* free_definite_size_function */
  85. &DefaultWinHeapAlignedMallocImpl,
  86. &DefaultWinHeapAlignedReallocImpl,
  87. &DefaultWinHeapAlignedFreeImpl,
  88. nullptr, /* next */
  89. };