8209958: Clean up duplicate basic array type statics in Universe
Reviewed-by: lfoltan, zgu
This commit is contained in:
parent
cea6e54978
commit
3559b6be76
src
hotspot/share
ci
memory
oops
prims
runtime
jdk.hotspot.agent/share/classes/sun/jvm/hotspot
test/hotspot/jtreg/serviceability/sa
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1999, 2018, 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
|
||||
@ -185,7 +185,7 @@ void ciObjectFactory::init_shared_objects() {
|
||||
|
||||
get_metadata(Universe::boolArrayKlassObj());
|
||||
get_metadata(Universe::charArrayKlassObj());
|
||||
get_metadata(Universe::singleArrayKlassObj());
|
||||
get_metadata(Universe::floatArrayKlassObj());
|
||||
get_metadata(Universe::doubleArrayKlassObj());
|
||||
get_metadata(Universe::byteArrayKlassObj());
|
||||
get_metadata(Universe::shortArrayKlassObj());
|
||||
|
@ -809,7 +809,7 @@ class CompileReplay : public StackObj {
|
||||
} else if (strcmp(field_signature, "[S") == 0) {
|
||||
value = oopFactory::new_shortArray(length, CHECK);
|
||||
} else if (strcmp(field_signature, "[F") == 0) {
|
||||
value = oopFactory::new_singleArray(length, CHECK);
|
||||
value = oopFactory::new_floatArray(length, CHECK);
|
||||
} else if (strcmp(field_signature, "[D") == 0) {
|
||||
value = oopFactory::new_doubleArray(length, CHECK);
|
||||
} else if (strcmp(field_signature, "[I") == 0) {
|
||||
|
@ -88,7 +88,7 @@ const char* KlassInfoEntry::name() const {
|
||||
} else {
|
||||
if (_klass == Universe::boolArrayKlassObj()) name = "<boolArrayKlass>"; else
|
||||
if (_klass == Universe::charArrayKlassObj()) name = "<charArrayKlass>"; else
|
||||
if (_klass == Universe::singleArrayKlassObj()) name = "<singleArrayKlass>"; else
|
||||
if (_klass == Universe::floatArrayKlassObj()) name = "<floatArrayKlass>"; else
|
||||
if (_klass == Universe::doubleArrayKlassObj()) name = "<doubleArrayKlass>"; else
|
||||
if (_klass == Universe::byteArrayKlassObj()) name = "<byteArrayKlass>"; else
|
||||
if (_klass == Universe::shortArrayKlassObj()) name = "<shortArrayKlass>"; else
|
||||
|
@ -412,7 +412,7 @@ void MetaspaceShared::serialize(SerializeClosure* soc) {
|
||||
soc->do_tag(sizeof(Symbol));
|
||||
|
||||
// Dump/restore miscellaneous metadata.
|
||||
Universe::serialize(soc, true);
|
||||
Universe::serialize(soc);
|
||||
soc->do_tag(--tag);
|
||||
|
||||
// Dump/restore references to commonly used names and signatures.
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 2018, 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
|
||||
@ -43,7 +43,7 @@ class oopFactory: AllStatic {
|
||||
// Basic type leaf array allocation
|
||||
static typeArrayOop new_boolArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::boolArrayKlassObj ())->allocate(length, THREAD); }
|
||||
static typeArrayOop new_charArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::charArrayKlassObj ())->allocate(length, THREAD); }
|
||||
static typeArrayOop new_singleArray(int length, TRAPS) { return TypeArrayKlass::cast(Universe::singleArrayKlassObj())->allocate(length, THREAD); }
|
||||
static typeArrayOop new_floatArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::floatArrayKlassObj())->allocate(length, THREAD); }
|
||||
static typeArrayOop new_doubleArray(int length, TRAPS) { return TypeArrayKlass::cast(Universe::doubleArrayKlassObj())->allocate(length, THREAD); }
|
||||
static typeArrayOop new_byteArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::byteArrayKlassObj ())->allocate(length, THREAD); }
|
||||
static typeArrayOop new_shortArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::shortArrayKlassObj ())->allocate(length, THREAD); }
|
||||
|
@ -83,16 +83,8 @@
|
||||
#include "utilities/preserveException.hpp"
|
||||
|
||||
// Known objects
|
||||
Klass* Universe::_boolArrayKlassObj = NULL;
|
||||
Klass* Universe::_byteArrayKlassObj = NULL;
|
||||
Klass* Universe::_charArrayKlassObj = NULL;
|
||||
Klass* Universe::_intArrayKlassObj = NULL;
|
||||
Klass* Universe::_shortArrayKlassObj = NULL;
|
||||
Klass* Universe::_longArrayKlassObj = NULL;
|
||||
Klass* Universe::_singleArrayKlassObj = NULL;
|
||||
Klass* Universe::_doubleArrayKlassObj = NULL;
|
||||
Klass* Universe::_typeArrayKlassObjs[T_VOID+1] = { NULL /*, NULL...*/ };
|
||||
Klass* Universe::_objectArrayKlassObj = NULL;
|
||||
Klass* Universe::_typeArrayKlassObjs[T_LONG+1] = { NULL /*, NULL...*/ };
|
||||
Klass* Universe::_objectArrayKlassObj = NULL;
|
||||
oop Universe::_int_mirror = NULL;
|
||||
oop Universe::_float_mirror = NULL;
|
||||
oop Universe::_double_mirror = NULL;
|
||||
@ -176,7 +168,7 @@ void Universe::basic_type_classes_do(KlassClosure *closure) {
|
||||
}
|
||||
}
|
||||
|
||||
void Universe::oops_do(OopClosure* f, bool do_all) {
|
||||
void Universe::oops_do(OopClosure* f) {
|
||||
|
||||
f->do_oop((oop*) &_int_mirror);
|
||||
f->do_oop((oop*) &_float_mirror);
|
||||
@ -220,15 +212,7 @@ void LatestMethodCache::metaspace_pointers_do(MetaspaceClosure* it) {
|
||||
}
|
||||
|
||||
void Universe::metaspace_pointers_do(MetaspaceClosure* it) {
|
||||
it->push(&_boolArrayKlassObj);
|
||||
it->push(&_byteArrayKlassObj);
|
||||
it->push(&_charArrayKlassObj);
|
||||
it->push(&_intArrayKlassObj);
|
||||
it->push(&_shortArrayKlassObj);
|
||||
it->push(&_longArrayKlassObj);
|
||||
it->push(&_singleArrayKlassObj);
|
||||
it->push(&_doubleArrayKlassObj);
|
||||
for (int i = 0; i < T_VOID+1; i++) {
|
||||
for (int i = 0; i < T_LONG+1; i++) {
|
||||
it->push(&_typeArrayKlassObjs[i]);
|
||||
}
|
||||
it->push(&_objectArrayKlassObj);
|
||||
@ -248,29 +232,13 @@ void Universe::metaspace_pointers_do(MetaspaceClosure* it) {
|
||||
}
|
||||
|
||||
// Serialize metadata and pointers to primitive type mirrors in and out of CDS archive
|
||||
void Universe::serialize(SerializeClosure* f, bool do_all) {
|
||||
void Universe::serialize(SerializeClosure* f) {
|
||||
|
||||
f->do_ptr((void**)&_boolArrayKlassObj);
|
||||
f->do_ptr((void**)&_byteArrayKlassObj);
|
||||
f->do_ptr((void**)&_charArrayKlassObj);
|
||||
f->do_ptr((void**)&_intArrayKlassObj);
|
||||
f->do_ptr((void**)&_shortArrayKlassObj);
|
||||
f->do_ptr((void**)&_longArrayKlassObj);
|
||||
f->do_ptr((void**)&_singleArrayKlassObj);
|
||||
f->do_ptr((void**)&_doubleArrayKlassObj);
|
||||
f->do_ptr((void**)&_objectArrayKlassObj);
|
||||
|
||||
{
|
||||
for (int i = 0; i < T_VOID+1; i++) {
|
||||
if (_typeArrayKlassObjs[i] != NULL) {
|
||||
assert(i >= T_BOOLEAN, "checking");
|
||||
f->do_ptr((void**)&_typeArrayKlassObjs[i]);
|
||||
} else if (do_all) {
|
||||
f->do_ptr((void**)&_typeArrayKlassObjs[i]);
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < T_LONG+1; i++) {
|
||||
f->do_ptr((void**)&_typeArrayKlassObjs[i]);
|
||||
}
|
||||
|
||||
f->do_ptr((void**)&_objectArrayKlassObj);
|
||||
#if INCLUDE_CDS_JAVA_HEAP
|
||||
// The mirrors are NULL if MetaspaceShared::is_heap_object_archiving_allowed
|
||||
// is false.
|
||||
@ -333,23 +301,9 @@ void Universe::genesis(TRAPS) {
|
||||
compute_base_vtable_size();
|
||||
|
||||
if (!UseSharedSpaces) {
|
||||
_boolArrayKlassObj = TypeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
|
||||
_charArrayKlassObj = TypeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK);
|
||||
_singleArrayKlassObj = TypeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK);
|
||||
_doubleArrayKlassObj = TypeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK);
|
||||
_byteArrayKlassObj = TypeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK);
|
||||
_shortArrayKlassObj = TypeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK);
|
||||
_intArrayKlassObj = TypeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK);
|
||||
_longArrayKlassObj = TypeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK);
|
||||
|
||||
_typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_CHAR] = _charArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_FLOAT] = _singleArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_DOUBLE] = _doubleArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_BYTE] = _byteArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_SHORT] = _shortArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_INT] = _intArrayKlassObj;
|
||||
_typeArrayKlassObjs[T_LONG] = _longArrayKlassObj;
|
||||
for (int i = T_BOOLEAN; i < T_LONG+1; i++) {
|
||||
_typeArrayKlassObjs[i] = TypeArrayKlass::create_klass((BasicType)i, CHECK);
|
||||
}
|
||||
|
||||
ClassLoaderData* null_cld = ClassLoaderData::the_null_class_loader_data();
|
||||
|
||||
@ -389,7 +343,7 @@ void Universe::genesis(TRAPS) {
|
||||
|
||||
initialize_basic_type_klass(boolArrayKlassObj(), CHECK);
|
||||
initialize_basic_type_klass(charArrayKlassObj(), CHECK);
|
||||
initialize_basic_type_klass(singleArrayKlassObj(), CHECK);
|
||||
initialize_basic_type_klass(floatArrayKlassObj(), CHECK);
|
||||
initialize_basic_type_klass(doubleArrayKlassObj(), CHECK);
|
||||
initialize_basic_type_klass(byteArrayKlassObj(), CHECK);
|
||||
initialize_basic_type_klass(shortArrayKlassObj(), CHECK);
|
||||
|
@ -112,16 +112,7 @@ class Universe: AllStatic {
|
||||
|
||||
private:
|
||||
// Known classes in the VM
|
||||
static Klass* _boolArrayKlassObj;
|
||||
static Klass* _byteArrayKlassObj;
|
||||
static Klass* _charArrayKlassObj;
|
||||
static Klass* _intArrayKlassObj;
|
||||
static Klass* _shortArrayKlassObj;
|
||||
static Klass* _longArrayKlassObj;
|
||||
static Klass* _singleArrayKlassObj;
|
||||
static Klass* _doubleArrayKlassObj;
|
||||
static Klass* _typeArrayKlassObjs[T_VOID+1];
|
||||
|
||||
static Klass* _typeArrayKlassObjs[T_LONG+1];
|
||||
static Klass* _objectArrayKlassObj;
|
||||
|
||||
// Known objects in the VM
|
||||
@ -270,21 +261,20 @@ class Universe: AllStatic {
|
||||
|
||||
public:
|
||||
// Known classes in the VM
|
||||
static Klass* boolArrayKlassObj() { return _boolArrayKlassObj; }
|
||||
static Klass* byteArrayKlassObj() { return _byteArrayKlassObj; }
|
||||
static Klass* charArrayKlassObj() { return _charArrayKlassObj; }
|
||||
static Klass* intArrayKlassObj() { return _intArrayKlassObj; }
|
||||
static Klass* shortArrayKlassObj() { return _shortArrayKlassObj; }
|
||||
static Klass* longArrayKlassObj() { return _longArrayKlassObj; }
|
||||
static Klass* singleArrayKlassObj() { return _singleArrayKlassObj; }
|
||||
static Klass* doubleArrayKlassObj() { return _doubleArrayKlassObj; }
|
||||
static Klass* boolArrayKlassObj() { return typeArrayKlassObj(T_BOOLEAN); }
|
||||
static Klass* byteArrayKlassObj() { return typeArrayKlassObj(T_BYTE); }
|
||||
static Klass* charArrayKlassObj() { return typeArrayKlassObj(T_CHAR); }
|
||||
static Klass* intArrayKlassObj() { return typeArrayKlassObj(T_INT); }
|
||||
static Klass* shortArrayKlassObj() { return typeArrayKlassObj(T_SHORT); }
|
||||
static Klass* longArrayKlassObj() { return typeArrayKlassObj(T_LONG); }
|
||||
static Klass* floatArrayKlassObj() { return typeArrayKlassObj(T_FLOAT); }
|
||||
static Klass* doubleArrayKlassObj() { return typeArrayKlassObj(T_DOUBLE); }
|
||||
|
||||
static Klass* objectArrayKlassObj() {
|
||||
return _objectArrayKlassObj;
|
||||
}
|
||||
static Klass* objectArrayKlassObj() { return _objectArrayKlassObj; }
|
||||
|
||||
static Klass* typeArrayKlassObj(BasicType t) {
|
||||
assert((uint)t < T_VOID+1, "range check for type: %s", type2name(t));
|
||||
assert((uint)t >= T_BOOLEAN, "range check for type: %s", type2name(t));
|
||||
assert((uint)t < T_LONG+1, "range check for type: %s", type2name(t));
|
||||
assert(_typeArrayKlassObjs[t] != NULL, "domain check");
|
||||
return _typeArrayKlassObjs[t];
|
||||
}
|
||||
@ -375,17 +365,6 @@ class Universe: AllStatic {
|
||||
static oop out_of_memory_error_realloc_objects() { return gen_out_of_memory_error(_out_of_memory_error_realloc_objects); }
|
||||
static oop delayed_stack_overflow_error_message() { return _delayed_stack_overflow_error_message; }
|
||||
|
||||
// Accessors needed for fast allocation
|
||||
static Klass** boolArrayKlassObj_addr() { return &_boolArrayKlassObj; }
|
||||
static Klass** byteArrayKlassObj_addr() { return &_byteArrayKlassObj; }
|
||||
static Klass** charArrayKlassObj_addr() { return &_charArrayKlassObj; }
|
||||
static Klass** intArrayKlassObj_addr() { return &_intArrayKlassObj; }
|
||||
static Klass** shortArrayKlassObj_addr() { return &_shortArrayKlassObj; }
|
||||
static Klass** longArrayKlassObj_addr() { return &_longArrayKlassObj; }
|
||||
static Klass** singleArrayKlassObj_addr() { return &_singleArrayKlassObj; }
|
||||
static Klass** doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; }
|
||||
static Klass** objectArrayKlassObj_addr() { return &_objectArrayKlassObj; }
|
||||
|
||||
// The particular choice of collected heap.
|
||||
static CollectedHeap* heap() { return _collectedHeap; }
|
||||
|
||||
@ -478,10 +457,10 @@ class Universe: AllStatic {
|
||||
|
||||
// Apply "f" to the addresses of all the direct heap pointers maintained
|
||||
// as static fields of "Universe".
|
||||
static void oops_do(OopClosure* f, bool do_all = false);
|
||||
static void oops_do(OopClosure* f);
|
||||
|
||||
// CDS support
|
||||
static void serialize(SerializeClosure* f, bool do_all = false);
|
||||
static void serialize(SerializeClosure* f);
|
||||
|
||||
// Apply "f" to all klasses for basic types (classes not present in
|
||||
// SystemDictionary).
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 2018, 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
|
||||
@ -56,10 +56,8 @@ class TypeArrayKlass : public ArrayKlass {
|
||||
// klass allocation
|
||||
static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
|
||||
TRAPS);
|
||||
static inline Klass* create_klass(BasicType type, int scale, TRAPS) {
|
||||
TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
|
||||
assert(scale == (1 << tak->log2_element_size()), "scale must check out");
|
||||
return tak;
|
||||
static TypeArrayKlass* create_klass(BasicType type, TRAPS) {
|
||||
return create_klass(type, external_name(type), THREAD);
|
||||
}
|
||||
|
||||
int oop_size(oop obj) const;
|
||||
|
@ -2687,7 +2687,7 @@ DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int,
|
||||
DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long,
|
||||
HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
|
||||
HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref))
|
||||
DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float,
|
||||
DEFINE_NEWSCALARARRAY(jfloatArray, new_floatArray, Float,
|
||||
HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
|
||||
HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
|
||||
DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double,
|
||||
|
@ -372,14 +372,6 @@ typedef PaddedEnd<ObjectMonitor> PaddedObjectMonitor;
|
||||
/* Universe */ \
|
||||
/************/ \
|
||||
\
|
||||
static_field(Universe, _boolArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _byteArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _charArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _intArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _shortArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _longArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _singleArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _doubleArrayKlassObj, Klass*) \
|
||||
static_field(Universe, _mirrors[0], oop) \
|
||||
static_field(Universe, _main_thread_group, oop) \
|
||||
static_field(Universe, _system_thread_group, oop) \
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2000, 2018, 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
|
||||
@ -53,16 +53,6 @@ public class Universe {
|
||||
private static sun.jvm.hotspot.types.OopField mainThreadGroupField;
|
||||
private static sun.jvm.hotspot.types.OopField systemThreadGroupField;
|
||||
|
||||
// single dimensional primitive array klasses
|
||||
private static sun.jvm.hotspot.types.AddressField boolArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField byteArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField charArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField intArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField shortArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField longArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField singleArrayKlassField;
|
||||
private static sun.jvm.hotspot.types.AddressField doubleArrayKlassField;
|
||||
|
||||
private static AddressField narrowOopBaseField;
|
||||
private static CIntegerField narrowOopShiftField;
|
||||
private static AddressField narrowKlassBaseField;
|
||||
@ -114,15 +104,6 @@ public class Universe {
|
||||
mainThreadGroupField = type.getOopField("_main_thread_group");
|
||||
systemThreadGroupField = type.getOopField("_system_thread_group");
|
||||
|
||||
boolArrayKlassField = type.getAddressField("_boolArrayKlassObj");
|
||||
byteArrayKlassField = type.getAddressField("_byteArrayKlassObj");
|
||||
charArrayKlassField = type.getAddressField("_charArrayKlassObj");
|
||||
intArrayKlassField = type.getAddressField("_intArrayKlassObj");
|
||||
shortArrayKlassField = type.getAddressField("_shortArrayKlassObj");
|
||||
longArrayKlassField = type.getAddressField("_longArrayKlassObj");
|
||||
singleArrayKlassField = type.getAddressField("_singleArrayKlassObj");
|
||||
doubleArrayKlassField = type.getAddressField("_doubleArrayKlassObj");
|
||||
|
||||
narrowOopBaseField = type.getAddressField("_narrow_oop._base");
|
||||
narrowOopShiftField = type.getCIntegerField("_narrow_oop._shift");
|
||||
narrowKlassBaseField = type.getAddressField("_narrow_klass._base");
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2000, 2018, 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
|
||||
@ -50,53 +50,6 @@ public class ObjectHeap {
|
||||
DEBUG = System.getProperty("sun.jvm.hotspot.oops.ObjectHeap.DEBUG") != null;
|
||||
}
|
||||
|
||||
private Address boolArrayKlassHandle;
|
||||
private Address byteArrayKlassHandle;
|
||||
private Address charArrayKlassHandle;
|
||||
private Address intArrayKlassHandle;
|
||||
private Address shortArrayKlassHandle;
|
||||
private Address longArrayKlassHandle;
|
||||
private Address singleArrayKlassHandle;
|
||||
private Address doubleArrayKlassHandle;
|
||||
|
||||
private TypeArrayKlass boolArrayKlassObj;
|
||||
private TypeArrayKlass byteArrayKlassObj;
|
||||
private TypeArrayKlass charArrayKlassObj;
|
||||
private TypeArrayKlass intArrayKlassObj;
|
||||
private TypeArrayKlass shortArrayKlassObj;
|
||||
private TypeArrayKlass longArrayKlassObj;
|
||||
private TypeArrayKlass singleArrayKlassObj;
|
||||
private TypeArrayKlass doubleArrayKlassObj;
|
||||
|
||||
public void initialize(TypeDataBase db) throws WrongTypeException {
|
||||
// Lookup the roots in the object hierarchy.
|
||||
Type universeType = db.lookupType("Universe");
|
||||
|
||||
boolArrayKlassHandle = universeType.getAddressField("_boolArrayKlassObj").getValue();
|
||||
boolArrayKlassObj = new TypeArrayKlass(boolArrayKlassHandle);
|
||||
|
||||
byteArrayKlassHandle = universeType.getAddressField("_byteArrayKlassObj").getValue();
|
||||
byteArrayKlassObj = new TypeArrayKlass(byteArrayKlassHandle);
|
||||
|
||||
charArrayKlassHandle = universeType.getAddressField("_charArrayKlassObj").getValue();
|
||||
charArrayKlassObj = new TypeArrayKlass(charArrayKlassHandle);
|
||||
|
||||
intArrayKlassHandle = universeType.getAddressField("_intArrayKlassObj").getValue();
|
||||
intArrayKlassObj = new TypeArrayKlass(intArrayKlassHandle);
|
||||
|
||||
shortArrayKlassHandle = universeType.getAddressField("_shortArrayKlassObj").getValue();
|
||||
shortArrayKlassObj = new TypeArrayKlass(shortArrayKlassHandle);
|
||||
|
||||
longArrayKlassHandle = universeType.getAddressField("_longArrayKlassObj").getValue();
|
||||
longArrayKlassObj = new TypeArrayKlass(longArrayKlassHandle);
|
||||
|
||||
singleArrayKlassHandle = universeType.getAddressField("_singleArrayKlassObj").getValue();
|
||||
singleArrayKlassObj = new TypeArrayKlass(singleArrayKlassHandle);
|
||||
|
||||
doubleArrayKlassHandle = universeType.getAddressField("_doubleArrayKlassObj").getValue();
|
||||
doubleArrayKlassObj = new TypeArrayKlass(doubleArrayKlassHandle);
|
||||
}
|
||||
|
||||
public ObjectHeap(TypeDataBase db) throws WrongTypeException {
|
||||
// Get commonly used sizes of basic types
|
||||
oopSize = VM.getVM().getOopSize();
|
||||
@ -108,8 +61,6 @@ public class ObjectHeap {
|
||||
longSize = db.getJLongType().getSize();
|
||||
floatSize = db.getJFloatType().getSize();
|
||||
doubleSize = db.getJDoubleType().getSize();
|
||||
|
||||
initialize(db);
|
||||
}
|
||||
|
||||
/** Comparison operation for oops, either or both of which may be null */
|
||||
@ -139,30 +90,6 @@ public class ObjectHeap {
|
||||
public long getFloatSize() { return floatSize; }
|
||||
public long getDoubleSize() { return doubleSize; }
|
||||
|
||||
// Accessors for well-known system classes (from Universe)
|
||||
public TypeArrayKlass getBoolArrayKlassObj() { return boolArrayKlassObj; }
|
||||
public TypeArrayKlass getByteArrayKlassObj() { return byteArrayKlassObj; }
|
||||
public TypeArrayKlass getCharArrayKlassObj() { return charArrayKlassObj; }
|
||||
public TypeArrayKlass getIntArrayKlassObj() { return intArrayKlassObj; }
|
||||
public TypeArrayKlass getShortArrayKlassObj() { return shortArrayKlassObj; }
|
||||
public TypeArrayKlass getLongArrayKlassObj() { return longArrayKlassObj; }
|
||||
public TypeArrayKlass getSingleArrayKlassObj() { return singleArrayKlassObj; }
|
||||
public TypeArrayKlass getDoubleArrayKlassObj() { return doubleArrayKlassObj; }
|
||||
|
||||
/** Takes a BasicType and returns the corresponding primitive array
|
||||
klass */
|
||||
public Klass typeArrayKlassObj(int t) {
|
||||
if (t == BasicType.getTBoolean()) return getBoolArrayKlassObj();
|
||||
if (t == BasicType.getTChar()) return getCharArrayKlassObj();
|
||||
if (t == BasicType.getTFloat()) return getSingleArrayKlassObj();
|
||||
if (t == BasicType.getTDouble()) return getDoubleArrayKlassObj();
|
||||
if (t == BasicType.getTByte()) return getByteArrayKlassObj();
|
||||
if (t == BasicType.getTShort()) return getShortArrayKlassObj();
|
||||
if (t == BasicType.getTInt()) return getIntArrayKlassObj();
|
||||
if (t == BasicType.getTLong()) return getLongArrayKlassObj();
|
||||
throw new RuntimeException("Illegal basic type " + t);
|
||||
}
|
||||
|
||||
/** an interface to filter objects while walking heap */
|
||||
public static interface ObjectFilter {
|
||||
public boolean canInclude(Oop obj);
|
||||
|
@ -75,8 +75,7 @@ public class ClhsdbPrintStatics {
|
||||
"Static fields of Universe",
|
||||
"uintptr_t Universe::_verify_oop_mask",
|
||||
"intptr_t Universe::_non_oop_bits",
|
||||
"bool Universe::_fully_initialized",
|
||||
"Universe::_doubleArrayKlassObj"));
|
||||
"bool Universe::_fully_initialized"));
|
||||
expStrMap.put("printstatics JvmtiExport", List.of(
|
||||
"Static fields of JvmtiExport",
|
||||
"bool JvmtiExport::_can_access_local_variables",
|
||||
|
Loading…
x
Reference in New Issue
Block a user