jdk8-mips64-public/hotspot: comparison src/share/vm/memory/allocation.hpp

-:7815eaceaa8c
+:6f817ce50129
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // member functions for printing. Classes that avoid allocating the
 // vtbl entries in the objects should therefore not be the printable
 // subclasses.
 //
 // The following macros and function should be used to allocate memory
-// directly in the resource area or in the C-heap:
+// directly in the resource area or in the C-heap, The _OBJECT variants
+// of the NEW_C_HEAP macros are used when a constructor and destructor
+// must be invoked for the object(s) and the objects are not inherited
+// from CHeapObj. The preferable way to allocate objects is using the
+// new operator.
+//
+// WARNING: The array variant must only be used for a homogenous array
+// where all objects are of the exact type specified. If subtypes are
+// stored in the array then the incorrect destructor might be called.
 //
 //   NEW_RESOURCE_ARRAY(type,size)
 //   NEW_RESOURCE_OBJ(type)
 //   NEW_C_HEAP_ARRAY(type,size)
 //   NEW_C_HEAP_OBJ(type)
+//   NEW_C_HEAP_OBJECT(type, memflags, pc, allocfail)
+//   NEW_C_HEAP_OBJECT_ARRAY(type, size, memflags, pc, allocfail)
+//   FREE_C_HEAP_OBJECT(type, objname, memflags)
+//   FREE_C_HEAP_OBJECT_ARRAY(type, size, arrayname, memflags)
 //   char* AllocateHeap(size_t size, const char* name);
 //   void  FreeHeap(void* p);
 //
 // C-heap allocation can be traced using +PrintHeapAllocation.
 // malloc and free should therefore never called directly.
 template <MEMFLAGS F> class CHeapObj ALLOCATION_SUPER_CLASS_SPEC {
 public:
 _NOINLINE_ void* operator new(size_t size, address caller_pc = 0);
 _NOINLINE_ void* operator new (size_t size, const std::nothrow_t&  nothrow_constant,
 address caller_pc = 0);
+_NOINLINE_ void* operator new [](size_t size, address caller_pc = 0);
+_NOINLINE_ void* operator new [](size_t size, const std::nothrow_t&  nothrow_constant,
+address caller_pc = 0);
 void  operator delete(void* p);
+void  operator delete [] (void* p);
 };
 // Base class for objects allocated on the stack only.
 // Calling new or delete will result in fatal error.
 class StackObj ALLOCATION_SUPER_CLASS_SPEC {
 private:
 void* operator new(size_t size);
 void  operator delete(void* p);
+void* operator new [](size_t size);
+void  operator delete [](void* p);
 };
 // Base class for objects used as value objects.
 // Calling new or delete will result in fatal error.
 //
 // be defined as a an empty string "".
 //
 class _ValueObj {
 private:
 void* operator new(size_t size);
-void operator delete(void* p);
+void  operator delete(void* p);
+void* operator new [](size_t size);
+void  operator delete [](void* p);
 };
 // Base class for objects stored in Metaspace.
 // Calling delete will result in fatal error.
 ~ResourceObj();
 #endif // ASSERT
 public:
 void* operator new(size_t size, allocation_type type, MEMFLAGS flags);
+void* operator new [](size_t size, allocation_type type, MEMFLAGS flags);
 void* operator new(size_t size, const std::nothrow_t&  nothrow_constant,
 allocation_type type, MEMFLAGS flags);
+void* operator new [](size_t size, const std::nothrow_t&  nothrow_constant,
+allocation_type type, MEMFLAGS flags);
 void* operator new(size_t size, Arena *arena) {
 address res = (address)arena->Amalloc(size);
 DEBUG_ONLY(set_allocation_type(res, ARENA);)
 return res;
 }
+void* operator new [](size_t size, Arena *arena) {
+address res = (address)arena->Amalloc(size);
+DEBUG_ONLY(set_allocation_type(res, ARENA);)
+return res;
+}
 void* operator new(size_t size) {
 address res = (address)resource_allocate_bytes(size);
 DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
 return res;
 }
 address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
 DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
 return res;
 }
+void* operator new [](size_t size) {
+address res = (address)resource_allocate_bytes(size);
+DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
+return res;
+}
+void* operator new [](size_t size, const std::nothrow_t& nothrow_constant) {
+address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
+DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
+return res;
+}
 void  operator delete(void* p);
+void  operator delete [](void* p);
 };
 // One of the following macros must be used when allocating an array
 // or object to determine whether it should reside in the C heap on in
 // the resource area.
 (type*) (AllocateHeap((size) * sizeof(type), memflags))
 #define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\
 (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags))
-#define FREE_C_HEAP_ARRAY(type,old,memflags) \
+#define FREE_C_HEAP_ARRAY(type, old, memflags) \
 FreeHeap((char*)(old), memflags)
+// allocate type in heap without calling ctor
+// WARNING: type must not have virtual functions!!! There is no way to initialize vtable.
 #define NEW_C_HEAP_OBJ(type, memflags)\
 NEW_C_HEAP_ARRAY(type, 1, memflags)
 #define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
 (type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
 #define REALLOC_C_HEAP_ARRAY2(type, old, size, memflags, pc)\
 (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, pc))
-#define NEW_C_HEAP_OBJ2(type, memflags, pc)\
+#define NEW_C_HEAP_ARRAY3(type, size, memflags, pc, allocfail)         \
-NEW_C_HEAP_ARRAY2(type, 1, memflags, pc)
+(type*) AllocateHeap(size * sizeof(type), memflags, pc, allocfail);
+// !!! Attention, see comments above about the usage !!!
+// allocate type in heap and call ctor
+#define NEW_C_HEAP_OBJECT(objname, type, memflags, pc, allocfail)\
+{                                                                                 \
+objname = (type*)AllocateHeap(sizeof(type), memflags, pc, allocfail);           \
+if (objname != NULL) ::new ((void *)objname) type();                            \
+}
+// allocate array of type, call ctor for every element in the array
+#define NEW_C_HEAP_OBJECT_ARRAY(array_name, type, size, memflags, pc, allocfail)    \
+{                                                                                 \
+array_name = (type*)AllocateHeap(size * sizeof(type), memflags, pc, allocfail); \
+if (array_name != NULL) {                                                       \
+for (int index = 0; index < size; index++) {                                  \
+::new ((void*)&array_name[index]) type();                                   \
+}                                                                             \
+}                                                                               \
+}
+// deallocate type in heap, call dtor
+#define FREE_C_HEAP_OBJECT(type, objname, memflags)                                 \
+if (objname != NULL) {                                                            \
+((type*)objname)->~type();                                                      \
+FREE_C_HEAP_ARRAY(type, objname, memflags);                                     \
+}
+// deallocate array of type with size, call dtor for every element in the array
+#define FREE_C_HEAP_OBJECT_ARRAY(type, array_name, size, memflags)                  \
+{                                                                                 \
+if (array_name != NULL) {                                                       \
+for (int index = 0; index < size; index++) {                                  \
+((type*)&array_name[index])->~type();                                       \
+}                                                                             \
+FREE_C_HEAP_ARRAY(type, array_name, memflags);                                \
+}                                                                               \
+}
 extern bool warn_new_operator;
 // for statistics
 #ifndef PRODUCT

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/allocation.hpp

src/share/vm/memory/allocation.hpp