< prev index next >

src/hotspot/share/memory/allocation.cpp

Print this page

 47   return p;
 48 }
 49 
 50 char* AllocateHeap(size_t size,
 51                    MEMFLAGS flags,
 52                    AllocFailType alloc_failmode /* = AllocFailStrategy::EXIT_OOM*/) {
 53   return AllocateHeap(size, flags, CALLER_PC);
 54 }
 55 
 56 char* ReallocateHeap(char *old,
 57                      size_t size,
 58                      MEMFLAGS flag,
 59                      AllocFailType alloc_failmode) {
 60   char* p = (char*) os::realloc(old, size, flag, CALLER_PC);
 61   if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
 62     vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "ReallocateHeap");
 63   }
 64   return p;
 65 }
 66 

 67 void FreeHeap(void* p) {
 68   os::free(p);
 69 }
 70 
 71 void* MetaspaceObj::_shared_metaspace_base = NULL;
 72 void* MetaspaceObj::_shared_metaspace_top  = NULL;
 73 
 74 void* StackObj::operator new(size_t size)     throw() { ShouldNotCallThis(); return 0; }
 75 void  StackObj::operator delete(void* p)              { ShouldNotCallThis(); }
 76 void* StackObj::operator new [](size_t size)  throw() { ShouldNotCallThis(); return 0; }
 77 void  StackObj::operator delete [](void* p)           { ShouldNotCallThis(); }
 78 
 79 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
 80                                  size_t word_size,
 81                                  MetaspaceObj::Type type, TRAPS) throw() {
 82   // Klass has it's own operator new
 83   return Metaspace::allocate(loader_data, word_size, type, THREAD);
 84 }
 85 
 86 bool MetaspaceObj::is_valid(const MetaspaceObj* p) {

 47   return p;
 48 }
 49 
 50 char* AllocateHeap(size_t size,
 51                    MEMFLAGS flags,
 52                    AllocFailType alloc_failmode /* = AllocFailStrategy::EXIT_OOM*/) {
 53   return AllocateHeap(size, flags, CALLER_PC);
 54 }
 55 
 56 char* ReallocateHeap(char *old,
 57                      size_t size,
 58                      MEMFLAGS flag,
 59                      AllocFailType alloc_failmode) {
 60   char* p = (char*) os::realloc(old, size, flag, CALLER_PC);
 61   if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
 62     vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "ReallocateHeap");
 63   }
 64   return p;
 65 }
 66 
 67 // handles NULL pointers
 68 void FreeHeap(void* p) {
 69   os::free(p);
 70 }
 71 
 72 void* MetaspaceObj::_shared_metaspace_base = NULL;
 73 void* MetaspaceObj::_shared_metaspace_top  = NULL;
 74 
 75 void* StackObj::operator new(size_t size)     throw() { ShouldNotCallThis(); return 0; }
 76 void  StackObj::operator delete(void* p)              { ShouldNotCallThis(); }
 77 void* StackObj::operator new [](size_t size)  throw() { ShouldNotCallThis(); return 0; }
 78 void  StackObj::operator delete [](void* p)           { ShouldNotCallThis(); }
 79 
 80 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
 81                                  size_t word_size,
 82                                  MetaspaceObj::Type type, TRAPS) throw() {
 83   // Klass has it's own operator new
 84   return Metaspace::allocate(loader_data, word_size, type, THREAD);
 85 }
 86 
 87 bool MetaspaceObj::is_valid(const MetaspaceObj* p) {
< prev index next >