src/hotspot/share/memory/allocation.cpp

*** 35,44 ****
--- 35,87 ----
  #include "runtime/task.hpp"
  #include "runtime/threadCritical.hpp"
  #include "services/memTracker.hpp"
  #include "utilities/ostream.hpp"
  
+ // allocate using malloc; will fail if no memory available
+ char* AllocateHeap(size_t size,
+                    MEMFLAGS flags,
+                    const NativeCallStack& stack,
+                    AllocFailType alloc_failmode) {
+   char* p = (char*) os::malloc(size, flags, stack);
+   if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
+     vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "AllocateHeap");
+   }
+   return p;
+ }
+ 
+ char* AllocateHeap(size_t size,
+                    MEMFLAGS flags) {
+   return AllocateHeap(size, flags, CALLER_PC);
+ }
+ char* AllocateHeap(size_t size,
+                    MEMFLAGS flags,
+                    const std::nothrow_t& nothrow_constant) {
+   return AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);
+ }
+ char* AllocateHeap(size_t size,
+                    MEMFLAGS flags,
+                    const std::nothrow_t& nothrow_constant,
+                    const NativeCallStack& stack) {
+   return AllocateHeap(size, flags, stack, AllocFailStrategy::RETURN_NULL);
+ }
+ 
+ char* ReallocateHeap(char *old,
+                      size_t size,
+                      MEMFLAGS flag,
+                      AllocFailType alloc_failmode) {
+   char* p = (char*) os::realloc(old, size, flag, CALLER_PC);
+   if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
+     vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "ReallocateHeap");
+   }
+   return p;
+ }
+ 
+ void FreeHeap(void* p) {
+   os::free(p);
+ }
+ 
  void* MetaspaceObj::_shared_metaspace_base = NULL;
  void* MetaspaceObj::_shared_metaspace_top  = NULL;
  
  void* StackObj::operator new(size_t size)     throw() { ShouldNotCallThis(); return 0; }
  void  StackObj::operator delete(void* p)              { ShouldNotCallThis(); }