# HG changeset patch # User coleenp # Date 1535494621 14400 # Node ID 5b0d864999603dd0351235df436f92ced1322658 # Parent 2c7a508ee1f4094f2a8fa2a539793b552612c516 8209958: Clean up duplicate basic array type statics in Universe Reviewed-by: lfoltan, zgu diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/ci/ciObjectFactory.cpp --- a/src/hotspot/share/ci/ciObjectFactory.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/ci/ciObjectFactory.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -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 @@ 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()); diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/ci/ciReplay.cpp --- a/src/hotspot/share/ci/ciReplay.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/ci/ciReplay.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -809,7 +809,7 @@ } 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) { diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/memory/heapInspection.cpp --- a/src/hotspot/share/memory/heapInspection.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/memory/heapInspection.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -88,7 +88,7 @@ } else { if (_klass == Universe::boolArrayKlassObj()) name = ""; else if (_klass == Universe::charArrayKlassObj()) name = ""; else - if (_klass == Universe::singleArrayKlassObj()) name = ""; else + if (_klass == Universe::floatArrayKlassObj()) name = ""; else if (_klass == Universe::doubleArrayKlassObj()) name = ""; else if (_klass == Universe::byteArrayKlassObj()) name = ""; else if (_klass == Universe::shortArrayKlassObj()) name = ""; else diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/memory/metaspaceShared.cpp --- a/src/hotspot/share/memory/metaspaceShared.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/memory/metaspaceShared.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -412,7 +412,7 @@ 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. diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/memory/oopFactory.hpp --- a/src/hotspot/share/memory/oopFactory.hpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/memory/oopFactory.hpp Tue Aug 28 18:17:01 2018 -0400 @@ -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 @@ // 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); } diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/memory/universe.cpp --- a/src/hotspot/share/memory/universe.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/memory/universe.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -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::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 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 @@ } // 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 @@ 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 @@ 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); diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/memory/universe.hpp --- a/src/hotspot/share/memory/universe.hpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/memory/universe.hpp Tue Aug 28 18:17:01 2018 -0400 @@ -112,16 +112,7 @@ 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 @@ 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 @@ 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 @@ // 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). diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/oops/typeArrayKlass.hpp --- a/src/hotspot/share/oops/typeArrayKlass.hpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/oops/typeArrayKlass.hpp Tue Aug 28 18:17:01 2018 -0400 @@ -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 @@ // 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; diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/prims/jni.cpp --- a/src/hotspot/share/prims/jni.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/prims/jni.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -2687,7 +2687,7 @@ 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, diff -r 2c7a508ee1f4 -r 5b0d86499960 src/hotspot/share/runtime/vmStructs.cpp --- a/src/hotspot/share/runtime/vmStructs.cpp Tue Aug 28 18:03:33 2018 -0400 +++ b/src/hotspot/share/runtime/vmStructs.cpp Tue Aug 28 18:17:01 2018 -0400 @@ -372,14 +372,6 @@ /* 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) \ diff -r 2c7a508ee1f4 -r 5b0d86499960 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/Universe.java --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/Universe.java Tue Aug 28 18:03:33 2018 -0400 +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/Universe.java Tue Aug 28 18:17:01 2018 -0400 @@ -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 @@ 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 @@ 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"); diff -r 2c7a508ee1f4 -r 5b0d86499960 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java Tue Aug 28 18:03:33 2018 -0400 +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java Tue Aug 28 18:17:01 2018 -0400 @@ -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 @@ 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 @@ 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 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); diff -r 2c7a508ee1f4 -r 5b0d86499960 test/hotspot/jtreg/serviceability/sa/ClhsdbPrintStatics.java --- a/test/hotspot/jtreg/serviceability/sa/ClhsdbPrintStatics.java Tue Aug 28 18:03:33 2018 -0400 +++ b/test/hotspot/jtreg/serviceability/sa/ClhsdbPrintStatics.java Tue Aug 28 18:17:01 2018 -0400 @@ -75,8 +75,7 @@ "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",