graal-compiler: src/share/vm/memory/allocation.hpp comparison

comparison src/share/vm/memory/allocation.hpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	43223d3f5dcd f2110083203d
children	6b0fd0964b87

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 // 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 _OBJ variants
-//
+// of the NEW/FREE_C_HEAP macros are used for alloc/dealloc simple
-//   NEW_RESOURCE_ARRAY(type,size)
+// objects which are not inherited from CHeapObj, note constructor and
+// destructor are not called. 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 must pay attention to calling destructors
+// at needed.
+//
+//   NEW_RESOURCE_ARRAY(type, size)
 //   NEW_RESOURCE_OBJ(type)
-//   NEW_C_HEAP_ARRAY(type,size)
+//   NEW_C_HEAP_ARRAY(type, size)
-//   NEW_C_HEAP_OBJ(type)
+//   NEW_C_HEAP_OBJ(type, memflags)
+//   FREE_C_HEAP_ARRAY(type, old, memflags)
+//   FREE_C_HEAP_OBJ(objname, type, 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.
 mtNMT               = 0x0A00,  // memory used by native memory tracking
 mtChunk             = 0x0B00,  // chunk that holds content of arenas
 mtJavaHeap          = 0x0C00,  // Java heap
 mtClassShared       = 0x0D00,  // class data sharing
 mtTest              = 0x0E00,  // Test type for verifying NMT
-mt_number_of_types  = 0x000E,  // number of memory types (mtDontTrack
+mtTracing           = 0x0F00,  // memory used for Tracing
+mt_number_of_types  = 0x000F,  // number of memory types (mtDontTrack
 // is not included as validate type)
 mtDontTrack         = 0x0F00,  // memory we do not or cannot track
 mt_masks            = 0x7F00,
 // object type mask
 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.
 bool is_metadata() const;
 bool is_metaspace_object() const;  // more specific test but slower
 bool is_shared() const;
 void print_address_on(outputStream* st) const;  // nonvirtual address printing
+#define METASPACE_OBJ_TYPES_DO(f) \
+f(Unknown) \
+f(Class) \
+f(Symbol) \
+f(TypeArrayU1) \
+f(TypeArrayU2) \
+f(TypeArrayU4) \
+f(TypeArrayU8) \
+f(TypeArrayOther) \
+f(Method) \
+f(ConstMethod) \
+f(MethodData) \
+f(ConstantPool) \
+f(ConstantPoolCache) \
+f(Annotation) \
+f(MethodCounters)
+#define METASPACE_OBJ_TYPE_DECLARE(name) name ## Type,
+#define METASPACE_OBJ_TYPE_NAME_CASE(name) case name ## Type: return #name;
+enum Type {
+// Types are MetaspaceObj::ClassType, MetaspaceObj::SymbolType, etc
+METASPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_DECLARE)
+_number_of_types
+};
+static const char * type_name(Type type) {
+switch(type) {
+METASPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_NAME_CASE)
+default:
+ShouldNotReachHere();
+return NULL;
+}
+}
+static MetaspaceObj::Type array_type(size_t elem_size) {
+switch (elem_size) {
+case 1: return TypeArrayU1Type;
+case 2: return TypeArrayU2Type;
+case 4: return TypeArrayU4Type;
+case 8: return TypeArrayU8Type;
+default:
+return TypeArrayOtherType;
+}
+}
 void* operator new(size_t size, ClassLoaderData* loader_data,
-size_t word_size, bool read_only, Thread* thread);
+size_t word_size, bool read_only,
+Type type, Thread* thread);
 // can't use TRAPS from this header file.
 void operator delete(void* p) { ShouldNotCallThis(); }
 };
 // Base class for classes that constitute name spaces.
 ~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.
 #define NEW_RESOURCE_ARRAY(type, size)\
 (type*) resource_allocate_bytes((size) * sizeof(type))
+#define NEW_RESOURCE_ARRAY_RETURN_NULL(type, size)\
+(type*) resource_allocate_bytes((size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
 #define NEW_RESOURCE_ARRAY_IN_THREAD(thread, type, size)\
 (type*) resource_allocate_bytes(thread, (size) * sizeof(type))
 #define REALLOC_RESOURCE_ARRAY(type, old, old_size, new_size)\
 (type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type), (new_size) * sizeof(type) )
 (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)
+#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_ARRAY3(type, size, memflags, pc, allocfail)         \
+(type*) AllocateHeap(size * sizeof(type), memflags, pc, allocfail)
+// allocate type in heap without calling ctor
 #define NEW_C_HEAP_OBJ(type, memflags)\
 NEW_C_HEAP_ARRAY(type, 1, memflags)
+// deallocate obj of type in heap without calling dtor
-#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
+#define FREE_C_HEAP_OBJ(objname, memflags)\
-(type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
+FreeHeap((char*)objname, memflags);
-#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)\
-NEW_C_HEAP_ARRAY2(type, 1, memflags, pc)
-extern bool warn_new_operator;
 // for statistics
 #ifndef PRODUCT
 class AllocStats : StackObj {
 julong start_mallocs, start_frees;

Mercurial > hg > graal-compiler

comparison src/share/vm/memory/allocation.hpp @ 10408:836a62f43af9