kmalloc.cpp 2.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151
  1. #include "kmalloc.h"
  2. #ifndef SERENITY
  3. #include <cstdio>
  4. #include <cstdlib>
  5. #endif
  6. #if defined(SERENITY) && defined(USERLAND)
  7. #define USE_SYSTEM_MALLOC
  8. #endif
  9. #define USE_SYSTEM_MALLOC
  10. #ifndef USE_SYSTEM_MALLOC
  11. #include "SimpleMalloc.h"
  12. #endif
  13. #ifdef USE_SYSTEM_MALLOC
  14. extern "C" {
  15. void* kcalloc(size_t nmemb, size_t size)
  16. {
  17. return calloc(nmemb, size);
  18. }
  19. void* kmalloc(size_t size)
  20. {
  21. return malloc(size);
  22. }
  23. void kfree(void* ptr)
  24. {
  25. free(ptr);
  26. }
  27. void* krealloc(void* ptr, size_t size)
  28. {
  29. return realloc(ptr, size);
  30. }
  31. void* kmalloc_eternal(size_t size)
  32. {
  33. return kmalloc(size);
  34. }
  35. }
  36. void* operator new(size_t size)
  37. {
  38. return kmalloc(size);
  39. }
  40. void* operator new[](size_t size)
  41. {
  42. return kmalloc(size);
  43. }
  44. void operator delete(void* ptr)
  45. {
  46. return kfree(ptr);
  47. }
  48. void operator delete[](void* ptr)
  49. {
  50. return kfree(ptr);
  51. }
  52. void operator delete(void* ptr, size_t)
  53. {
  54. return kfree(ptr);
  55. }
  56. void operator delete[](void* ptr, size_t)
  57. {
  58. return kfree(ptr);
  59. }
  60. #else
  61. extern "C" {
  62. void* kcalloc(size_t nmemb, size_t size)
  63. {
  64. if (!nmemb || !size)
  65. return nullptr;
  66. return SimpleMalloc::allocate_zeroed(nmemb * size);
  67. }
  68. void* kmalloc(size_t size)
  69. {
  70. if (!size)
  71. return nullptr;
  72. return SimpleMalloc::allocate(size);
  73. }
  74. void* kmalloc_eternal(size_t size)
  75. {
  76. if (!size)
  77. return nullptr;
  78. return SimpleMalloc::allocate(size);
  79. }
  80. void kfree(void* ptr)
  81. {
  82. if (!ptr)
  83. return;
  84. SimpleMalloc::free((byte*)ptr);
  85. }
  86. void* krealloc(void* ptr, size_t size)
  87. {
  88. if (!ptr)
  89. return ptr;
  90. return SimpleMalloc::reallocate((byte*)ptr, size);
  91. }
  92. }
  93. void* operator new(std::size_t size)
  94. {
  95. return kmalloc(size);
  96. }
  97. void* operator new[](std::size_t size)
  98. {
  99. return kmalloc(size);
  100. }
  101. void operator delete(void* ptr)
  102. {
  103. return kfree(ptr);
  104. }
  105. void operator delete[](void* ptr)
  106. {
  107. return kfree(ptr);
  108. }
  109. void operator delete(void* ptr, size_t)
  110. {
  111. return kfree(ptr);
  112. }
  113. void operator delete[](void* ptr, size_t)
  114. {
  115. return kfree(ptr);
  116. }
  117. #endif