8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder

Reviewed-by: dholmes, hseigel
This commit is contained in:
Thomas Schatzl 2018-08-08 15:31:07 +02:00
parent e98c176026
commit 9c0720b156
61 changed files with 129 additions and 129 deletions

@ -142,19 +142,22 @@ void ClassLoaderData::initialize_name(Handle class_loader) {
}
ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous) :
_is_anonymous(is_anonymous),
_metaspace(NULL),
_metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
Monitor::_safepoint_check_never)),
_unloading(false), _is_anonymous(is_anonymous),
_modified_oops(true), _accumulated_modified_oops(false),
// An anonymous class loader data doesn't have anything to keep
// it from being unloaded during parsing of the anonymous class.
// The null-class-loader should always be kept alive.
_keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0),
_metaspace(NULL), _unloading(false), _klasses(NULL),
_modules(NULL), _packages(NULL), _unnamed_module(NULL), _dictionary(NULL),
_claimed(0), _modified_oops(true), _accumulated_modified_oops(false),
_jmethod_ids(NULL), _handles(), _deallocate_list(NULL),
_claimed(0),
_handles(),
_klasses(NULL), _packages(NULL), _modules(NULL), _unnamed_module(NULL), _dictionary(NULL),
_jmethod_ids(NULL),
_deallocate_list(NULL),
_next(NULL),
_class_loader_klass(NULL), _name(NULL), _name_and_id(NULL),
_metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
Monitor::_safepoint_check_never)) {
_class_loader_klass(NULL), _name(NULL), _name_and_id(NULL) {
if (!h_class_loader.is_null()) {
_class_loader = _handles.add(h_class_loader());

@ -185,7 +185,7 @@ class ClassLoaderData : public CHeapObj<mtClass> {
volatile juint _size;
Chunk* _next;
Chunk(Chunk* c) : _next(c), _size(0) { }
Chunk(Chunk* c) : _size(0), _next(c) { }
};
Chunk* volatile _head;

@ -299,7 +299,7 @@ public:
LoaderTreeNode(const oop loader_oop)
: _loader_oop(loader_oop), _cld(NULL), _child(NULL), _next(NULL),
_classes(NULL), _anon_classes(NULL), _num_classes(0), _num_anon_classes(0),
_classes(NULL), _num_classes(0), _anon_classes(NULL), _num_anon_classes(0),
_num_folded(0)
{}

@ -87,8 +87,8 @@ public:
_chunk_sz(0),
_block_sz(0),
_classes_count(0),
_anon_block_sz(0),
_anon_chunk_sz(0),
_anon_block_sz(0),
_anon_classes_count(0) {
}
};
@ -118,11 +118,11 @@ protected:
public:
ClassLoaderStatsClosure(outputStream* out) :
_out(out),
_stats(new StatsTable()),
_total_loaders(0),
_total_block_sz(0),
_total_chunk_sz(0),
_total_classes(0),
_stats(new StatsTable()) {
_total_chunk_sz(0),
_total_block_sz(0) {
}
virtual void do_cld(ClassLoaderData* cld);

@ -688,8 +688,8 @@ class FindMethodsByErasedSig : public HierarchyVisitor<FindMethodsByErasedSig> {
public:
FindMethodsByErasedSig(Symbol* name, Symbol* signature, bool is_interf) :
_method_name(name), _method_signature(signature), _cur_class_is_interface(is_interf),
_family(NULL) {}
_method_name(name), _method_signature(signature), _family(NULL),
_cur_class_is_interface(is_interf) {}
void get_discovered_family(MethodFamily** family) {
if (_family != NULL) {

@ -53,16 +53,16 @@ size_t Dictionary::entry_size() {
}
Dictionary::Dictionary(ClassLoaderData* loader_data, int table_size, bool resizable)
: _loader_data(loader_data), _resizable(resizable), _needs_resizing(false),
Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size()) {
: Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size()),
_resizable(resizable), _needs_resizing(false), _loader_data(loader_data) {
};
Dictionary::Dictionary(ClassLoaderData* loader_data,
int table_size, HashtableBucket<mtClass>* t,
int number_of_entries, bool resizable)
: _loader_data(loader_data), _resizable(resizable), _needs_resizing(false),
Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size(), t, number_of_entries) {
: Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size(), t, number_of_entries),
_resizable(resizable), _needs_resizing(false), _loader_data(loader_data) {
};
Dictionary::~Dictionary() {

@ -2005,7 +2005,7 @@ class BacktraceBuilder: public StackObj {
public:
// constructor for new backtrace
BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _names(NULL) {
BacktraceBuilder(TRAPS): _head(NULL), _methods(NULL), _bcis(NULL), _mirrors(NULL), _names(NULL) {
expand(CHECK);
_backtrace = Handle(THREAD, _head);
_index = 0;
@ -2102,7 +2102,7 @@ struct BacktraceElement : public StackObj {
Symbol* _name;
Handle _mirror;
BacktraceElement(Handle mirror, int mid, int version, int bci, Symbol* name) :
_mirror(mirror), _method_id(mid), _version(version), _bci(bci), _name(name) {}
_method_id(mid), _bci(bci), _version(version), _name(name), _mirror(mirror) {}
};
class BacktraceIterator : public StackObj {

@ -33,8 +33,8 @@
StackMapFrame::StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* v) :
_offset(0), _locals_size(0), _stack_size(0),
_stack_mark(0), _flags(0), _max_locals(max_locals),
_max_stack(max_stack), _verifier(v) {
_stack_mark(0), _max_locals(max_locals),
_max_stack(max_stack), _flags(0), _verifier(v) {
Thread* thr = v->thread();
_locals = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_locals);
_stack = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_stack);

@ -105,12 +105,12 @@ class StackMapFrame : public ResourceObj {
u2 max_stack,
VerificationType* locals,
VerificationType* stack,
ClassVerifier* v) : _offset(offset), _flags(flags),
ClassVerifier* v) : _offset(offset),
_locals_size(locals_size),
_stack_size(stack_size),
_stack_mark(-1),
_max_locals(max_locals),
_max_stack(max_stack),
_max_stack(max_stack), _flags(flags),
_locals(locals), _stack(stack),
_verifier(v) { }

@ -122,7 +122,7 @@ class StringTableLookupJchar : StackObj {
public:
StringTableLookupJchar(Thread* thread, uintx hash, const jchar* key, int len)
: _thread(thread), _hash(hash), _str(key), _len(len) {
: _thread(thread), _hash(hash), _len(len), _str(key) {
}
uintx get_hash() const {
return _hash;

@ -159,21 +159,21 @@ class LinkInfo : public StackObj {
LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, Klass* current_klass,
AccessCheck check_access = needs_access_check,
constantTag tag = JVM_CONSTANT_Invalid) :
_resolved_klass(resolved_klass),
_name(name), _signature(signature), _current_klass(current_klass), _current_method(methodHandle()),
_name(name),
_signature(signature), _resolved_klass(resolved_klass), _current_klass(current_klass), _current_method(methodHandle()),
_check_access(check_access == needs_access_check), _tag(tag) {}
LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, const methodHandle& current_method,
AccessCheck check_access = needs_access_check,
constantTag tag = JVM_CONSTANT_Invalid) :
_resolved_klass(resolved_klass),
_name(name), _signature(signature), _current_klass(current_method->method_holder()), _current_method(current_method),
_name(name),
_signature(signature), _resolved_klass(resolved_klass), _current_klass(current_method->method_holder()), _current_method(current_method),
_check_access(check_access == needs_access_check), _tag(tag) {}
// Case where we just find the method and don't check access against the current class
LinkInfo(Klass* resolved_klass, Symbol*name, Symbol* signature) :
_resolved_klass(resolved_klass),
_name(name), _signature(signature), _current_klass(NULL), _current_method(methodHandle()),
_name(name),
_signature(signature), _resolved_klass(resolved_klass), _current_klass(NULL), _current_method(methodHandle()),
_check_access(false), _tag(JVM_CONSTANT_Invalid) {}
// accessors

@ -345,8 +345,8 @@ JfrStartFlightRecordingDCmd::JfrStartFlightRecordingDCmd(outputStream* output,
_settings("settings", "Settings file(s), e.g. profile or default. See JRE_HOME/lib/jfr", "STRING SET", false),
_delay("delay", "Delay recording start with (s)econds, (m)inutes), (h)ours), or (d)ays, e.g. 5h.", "NANOTIME", false, "0"),
_duration("duration", "Duration of recording in (s)econds, (m)inutes, (h)ours, or (d)ays, e.g. 300s.", "NANOTIME", false, "0"),
_filename("filename", "Resulting recording filename, e.g. \\\"" JFR_FILENAME_EXAMPLE "\\\"", "STRING", false),
_disk("disk", "Recording should be persisted to disk", "BOOLEAN", false),
_filename("filename", "Resulting recording filename, e.g. \\\"" JFR_FILENAME_EXAMPLE "\\\"", "STRING", false),
_maxage("maxage", "Maximum time to keep recorded data (on disk) in (s)econds, (m)inutes, (h)ours, or (d)ays, e.g. 60m, or 0 for no limit", "NANOTIME", false, "0"),
_maxsize("maxsize", "Maximum amount of bytes to keep (on disk) in (k)B, (M)B or (G)B, e.g. 500M, or 0 for no limit", "MEMORY SIZE", false, "0"),
_dump_on_exit("dumponexit", "Dump running recording when JVM shuts down", "BOOLEAN", false),

@ -265,8 +265,8 @@ class AnnotationElementIterator : public StackObj {
AnnotationElementIterator(const InstanceKlass* ik, address buffer, u2 limit) : _ik(ik),
_buffer(buffer),
_limit(limit),
_next(element_name_offset),
_current(element_name_offset) {
_current(element_name_offset),
_next(element_name_offset) {
assert(_buffer != NULL, "invariant");
assert(_next == element_name_offset, "invariant");
assert(_current == element_name_offset, "invariant");
@ -319,10 +319,10 @@ class AnnotationIterator : public StackObj {
public:
AnnotationIterator(const InstanceKlass* ik, AnnotationArray* ar) : _ik(ik),
_current(0),
_next(0),
_limit(ar != NULL ? ar->length() : 0),
_buffer(_limit > 2 ? ar->adr_at(2) : NULL) {
_buffer(_limit > 2 ? ar->adr_at(2) : NULL),
_current(0),
_next(0) {
if (_buffer != NULL) {
_limit -= 2; // subtract sizeof(u2) number of annotations field
}

@ -31,9 +31,9 @@ SampleList::SampleList(size_t limit, size_t cache_size) :
_free_list(),
_in_use_list(),
_last_resolved(NULL),
_allocated(0),
_limit(limit),
_cache_size(cache_size),
_allocated(0) {
_cache_size(cache_size) {
}
SampleList::~SampleList() {

@ -37,7 +37,7 @@ class JfrGetCallTrace : public StackObj {
bool _in_java;
public:
JfrGetCallTrace(bool in_java, JavaThread* thread) : _in_java(in_java), _thread(thread) {}
JfrGetCallTrace(bool in_java, JavaThread* thread) : _thread(thread), _in_java(in_java) {}
bool find_top_frame(frame& topframe, Method** method, frame& first_frame);
bool get_topframe(void* ucontext, frame& top);
};

@ -28,7 +28,7 @@
#include "oops/oop.inline.hpp"
#include "oops/symbol.hpp"
JfrSymbolId::JfrSymbolId() : _symbol_id_counter(0), _sym_table(new SymbolTable(this)), _cstring_table(new CStringTable(this)) {
JfrSymbolId::JfrSymbolId() : _sym_table(new SymbolTable(this)), _cstring_table(new CStringTable(this)), _symbol_id_counter(0) {
assert(_sym_table != NULL, "invariant");
assert(_cstring_table != NULL, "invariant");
initialize();

@ -239,8 +239,8 @@ JfrRecorderService::JfrRecorderService() :
_checkpoint_manager(JfrCheckpointManager::instance()),
_chunkwriter(JfrRepository::chunkwriter()),
_repository(JfrRepository::instance()),
_storage(JfrStorage::instance()),
_stack_trace_repository(JfrStackTraceRepository::instance()),
_storage(JfrStorage::instance()),
_string_pool(JfrStringPool::instance()) {}
void JfrRecorderService::start() {

@ -78,8 +78,8 @@ class JfrStackTrace : public StackObj {
_id(0),
_nr_of_frames(0),
_hash(0),
_reached_root(false),
_max_frames(max_frames),
_reached_root(false),
_lineno(false) {}
bool record_thread(JavaThread& thread, frame& frame);
bool record_safe(JavaThread* thread, int skip, bool leakp = false);

@ -54,8 +54,8 @@ public:
// doubled in size; the total amount of EXTRA times all hash functions are
// computed for the doubling is no more than the current size - thus the
// doubling in size costs no more than a constant factor in speed.
Dict::Dict(CmpKey initcmp, Hash inithash) : _hash(inithash), _cmp(initcmp),
_arena(Thread::current()->resource_area()) {
Dict::Dict(CmpKey initcmp, Hash inithash) : _arena(Thread::current()->resource_area()),
_hash(inithash), _cmp(initcmp) {
int i;
// Precompute table of null character hashes
@ -74,7 +74,7 @@ Dict::Dict(CmpKey initcmp, Hash inithash) : _hash(inithash), _cmp(initcmp),
}
Dict::Dict(CmpKey initcmp, Hash inithash, Arena *arena, int size)
: _hash(inithash), _cmp(initcmp), _arena(arena) {
: _arena(arena), _hash(inithash), _cmp(initcmp) {
int i;
// Precompute table of null character hashes
@ -161,7 +161,7 @@ void Dict::doubhash(void) {
//------------------------------Dict-----------------------------------------
// Deep copy a dictionary.
Dict::Dict( const Dict &d ) : _size(d._size), _cnt(d._cnt), _hash(d._hash),_cmp(d._cmp), _arena(d._arena) {
Dict::Dict( const Dict &d ) : _arena(d._arena), _size(d._size), _cnt(d._cnt), _hash(d._hash), _cmp(d._cmp) {
_bin = (bucket*)_arena->Amalloc_4(sizeof(bucket)*_size);
memcpy( (void*)_bin, (void*)d._bin, sizeof(bucket)*_size );
for( uint i=0; i<_size; i++ ) {

@ -44,9 +44,9 @@ char LogFileOutput::_vm_start_time_str[StartTimeBufferSize];
LogFileOutput::LogFileOutput(const char* name)
: LogFileStreamOutput(NULL), _name(os::strdup_check_oom(name, mtLogging)),
_file_name(NULL), _archive_name(NULL), _archive_name_len(0),
_rotate_size(DefaultFileSize), _file_count(DefaultFileCount),
_current_size(0), _current_file(0), _rotation_semaphore(1) {
_file_name(NULL), _archive_name(NULL), _current_file(0),
_file_count(DefaultFileCount), _archive_name_len(0),
_rotate_size(DefaultFileSize), _current_size(0), _rotation_semaphore(1) {
assert(strstr(name, Prefix) == name, "invalid output name '%s': missing prefix: %s", name, Prefix);
_file_name = make_file_name(name + strlen(Prefix), _pid_str, _vm_start_time_str);
}

@ -72,7 +72,7 @@ class LogMessageBuffer : public StackObj {
public:
Iterator(const LogMessageBuffer& message, LogLevelType level, LogDecorations& decorations)
: _message(message), _level(level), _decorations(decorations), _current_line_index(0) {
: _message(message), _current_line_index(0), _level(level), _decorations(decorations) {
skip_messages_with_finer_level();
}

@ -192,7 +192,7 @@ class KlassInfoEntry: public CHeapObj<mtInternal> {
public:
KlassInfoEntry(Klass* k, KlassInfoEntry* next) :
_klass(k), _instance_count(0), _instance_words(0), _next(next), _index(-1),
_next(next), _klass(k), _instance_count(0), _instance_words(0), _index(-1),
_do_print(false), _subclasses(NULL)
{}
~KlassInfoEntry();

@ -1364,8 +1364,8 @@ bool Metaspace::contains_non_shared(const void* ptr) {
// ClassLoaderMetaspace
ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType type)
: _lock(lock)
, _space_type(type)
: _space_type(type)
, _lock(lock)
, _vsm(NULL)
, _class_vsm(NULL)
{

@ -53,13 +53,13 @@ size_t Metachunk::overhead() {
Metachunk::Metachunk(ChunkIndex chunktype, bool is_class, size_t word_size,
VirtualSpaceNode* container)
: Metabase<Metachunk>(word_size),
_container(container),
_top(NULL),
_sentinel(CHUNK_SENTINEL),
_chunk_type(chunktype),
_is_class(is_class),
_sentinel(CHUNK_SENTINEL),
_origin(origin_normal),
_use_count(0),
_top(NULL),
_container(container)
_use_count(0)
{
_top = initial_top();
set_is_tagged_free(false);

@ -35,14 +35,14 @@ MetaspaceDCmd::MetaspaceDCmd(outputStream* output, bool heap)
: DCmdWithParser(output, heap)
, _basic("basic", "Prints a basic summary (does not need a safepoint).", "BOOLEAN", false, "false")
, _show_loaders("show-loaders", "Shows usage by class loader.", "BOOLEAN", false, "false")
, _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
, _by_chunktype("by-chunktype", "Break down numbers by chunk type.", "BOOLEAN", false, "false")
, _by_spacetype("by-spacetype", "Break down numbers by loader type.", "BOOLEAN", false, "false")
, _by_chunktype("by-chunktype", "Break down numbers by chunk type.", "BOOLEAN", false, "false")
, _show_vslist("vslist", "Shows details about the underlying virtual space.", "BOOLEAN", false, "false")
, _show_vsmap("vsmap", "Shows chunk composition of the underlying virtual spaces", "BOOLEAN", false, "false")
, _scale("scale", "Memory usage in which to scale. Valid values are: 1, KB, MB or GB (fixed scale) "
"or \"dynamic\" for a dynamically choosen scale.",
"STRING", false, "dynamic")
"STRING", false, "dynamic")
, _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
{
_dcmdparser.add_dcmd_option(&_basic);
_dcmdparser.add_dcmd_option(&_show_loaders);

@ -38,7 +38,7 @@ PrintCLDMetaspaceInfoClosure::PrintCLDMetaspaceInfoClosure(outputStream* out, si
bool do_print_classes, bool break_down_by_chunktype)
: _out(out), _scale(scale), _do_print(do_print), _do_print_classes(do_print_classes)
, _break_down_by_chunktype(break_down_by_chunktype)
, _num_loaders(0), _num_loaders_unloading(0), _num_loaders_without_metaspace(0)
, _num_loaders(0), _num_loaders_without_metaspace(0), _num_loaders_unloading(0)
{
memset(_num_loaders_by_spacetype, 0, sizeof(_num_loaders_by_spacetype));
}

@ -228,16 +228,15 @@ void SpaceManager::print_on(outputStream* st) const {
SpaceManager::SpaceManager(Metaspace::MetadataType mdtype,
Metaspace::MetaspaceType space_type,//
Mutex* lock) :
_lock(lock),
_mdtype(mdtype),
_space_type(space_type),
_chunk_list(NULL),
_current_chunk(NULL),
_overhead_words(0),
_capacity_words(0),
_used_words(0),
_overhead_words(0),
_block_freelists(NULL),
_lock(lock),
_chunk_list(NULL),
_current_chunk(NULL)
{
_block_freelists(NULL) {
Metadebug::init_allocation_fail_alot_count();
memset(_num_chunks_by_type, 0, sizeof(_num_chunks_by_type));
log_trace(gc, metaspace, freelist)("SpaceManager(): " PTR_FORMAT, p2i(this));

@ -149,9 +149,9 @@ void VirtualSpaceList::retire_current_virtual_space() {
}
VirtualSpaceList::VirtualSpaceList(size_t word_size) :
_is_class(false),
_virtual_space_list(NULL),
_current_virtual_space(NULL),
_is_class(false),
_reserved_words(0),
_committed_words(0),
_virtual_space_count(0) {
@ -161,9 +161,9 @@ VirtualSpaceList::VirtualSpaceList(size_t word_size) :
}
VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
_is_class(true),
_virtual_space_list(NULL),
_current_virtual_space(NULL),
_is_class(true),
_reserved_words(0),
_committed_words(0),
_virtual_space_count(0) {

@ -57,7 +57,7 @@ static bool should_commit_large_pages_when_reserving(size_t bytes) {
// byte_size is the size of the associated virtualspace.
VirtualSpaceNode::VirtualSpaceNode(bool is_class, size_t bytes) :
_is_class(is_class), _top(NULL), _next(NULL), _rs(), _container_count(0), _occupancy_map(NULL) {
_next(NULL), _is_class(is_class), _rs(), _top(NULL), _container_count(0), _occupancy_map(NULL) {
assert_is_aligned(bytes, Metaspace::reserve_alignment());
bool large_pages = should_commit_large_pages_when_reserving(bytes);
_rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);

@ -79,7 +79,7 @@ class VirtualSpaceNode : public CHeapObj<mtClass> {
VirtualSpaceNode(bool is_class, size_t byte_size);
VirtualSpaceNode(bool is_class, ReservedSpace rs) :
_is_class(is_class), _top(NULL), _next(NULL), _rs(rs), _container_count(0), _occupancy_map(NULL) {}
_next(NULL), _is_class(is_class), _rs(rs), _top(NULL), _container_count(0), _occupancy_map(NULL) {}
~VirtualSpaceNode();
// Convenience functions for logical bottom and end

@ -36,7 +36,7 @@
// Dummy constructor
ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0),
_alignment(0), _special(false), _executable(false), _fd_for_heap(-1) {
_alignment(0), _special(false), _fd_for_heap(-1), _executable(false) {
}
ReservedSpace::ReservedSpace(size_t size, size_t preferred_page_size) : _fd_for_heap(-1) {

@ -966,7 +966,7 @@ class SymbolHashMapEntry : public CHeapObj<mtSymbol> {
void set_value(u2 value) { _value = value; }
SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value)
: _hash(hash), _symbol(symbol), _value(value), _next(NULL) {}
: _hash(hash), _next(NULL), _symbol(symbol), _value(value) {}
}; // End SymbolHashMapEntry class

@ -402,13 +402,13 @@ Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind, KlassID id) :
Klass(id),
_nest_members(NULL),
_nest_host_index(0),
_nest_host(NULL),
_static_field_size(parser.static_field_size()),
_nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())),
_itable_len(parser.itable_size()),
_reference_type(parser.reference_type()),
_nest_members(NULL),
_nest_host_index(0),
_nest_host(NULL) {
_reference_type(parser.reference_type()) {
set_vtable_length(parser.vtable_size());
set_kind(kind);
set_access_flags(parser.access_flags());

@ -191,9 +191,9 @@ void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word
// Need to set the _java_mirror field explicitly to not hit an assert that the field
// should be NULL before setting it.
Klass::Klass(KlassID id) : _id(id),
_java_mirror(NULL),
_prototype_header(markOopDesc::prototype()),
_shared_class_path_index(-1),
_java_mirror(NULL) {
_shared_class_path_index(-1) {
CDS_ONLY(_shared_class_flags = 0;)
CDS_JAVA_HEAP_ONLY(_archived_mirror = 0;)
_primary_supers[0] = this;

@ -2051,7 +2051,7 @@ class JNIMethodBlock : public CHeapObj<mtClass> {
// Something that can't be mistaken for an address or a markOop
Method* const JNIMethodBlock::_free_method = (Method*)55;
JNIMethodBlockNode::JNIMethodBlockNode(int num_methods) : _next(NULL), _top(0) {
JNIMethodBlockNode::JNIMethodBlockNode(int num_methods) : _top(0), _next(NULL) {
_number_of_methods = MAX2(num_methods, min_block_size);
_methods = NEW_C_HEAP_ARRAY(Method*, _number_of_methods, mtInternal);
for (int i = 0; i < _number_of_methods; i++) {

@ -733,7 +733,7 @@ protected:
const int _base_off;
TypeEntries(int base_off)
: _base_off(base_off), _pd(NULL) {}
: _pd(NULL), _base_off(base_off) {}
void set_intptr_at(int index, intptr_t value) {
_pd->set_intptr_at(index, value);

@ -41,7 +41,7 @@ private:
Thread* _cur_thread;
public:
LoadedClassesClosure(Thread* thread, JvmtiEnv* env) : _cur_thread(thread), _env(env) {
LoadedClassesClosure(Thread* thread, JvmtiEnv* env) : _env(env), _cur_thread(thread) {
assert(_cur_thread == Thread::current(), "must be current thread");
}

@ -531,8 +531,8 @@ VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, B
, _depth(depth)
, _index(index)
, _type(type)
, _set(false)
, _jvf(NULL)
, _set(false)
, _result(JVMTI_ERROR_NONE)
{
}
@ -545,8 +545,8 @@ VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, B
, _index(index)
, _type(type)
, _value(value)
, _set(true)
, _jvf(NULL)
, _set(true)
, _result(JVMTI_ERROR_NONE)
{
}
@ -558,8 +558,8 @@ VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_threa
, _depth(depth)
, _index(index)
, _type(T_OBJECT)
, _set(false)
, _jvf(NULL)
, _set(false)
, _result(JVMTI_ERROR_NONE)
{
}

@ -779,7 +779,7 @@ class ClassFieldDescriptor: public CHeapObj<mtInternal> {
char _field_type;
public:
ClassFieldDescriptor(int index, char type, int offset) :
_field_index(index), _field_type(type), _field_offset(offset) {
_field_index(index), _field_offset(offset), _field_type(type) {
}
int field_index() const { return _field_index; }
char field_type() const { return _field_type; }

@ -75,8 +75,7 @@ class VM_Handshake: public VM_Operation {
HandshakeThreadsOperation* const _op;
VM_Handshake(HandshakeThreadsOperation* op) :
_op(op),
_handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)) {}
_handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
void set_handshake(JavaThread* target) {
target->set_handshake_operation(_op);

@ -80,8 +80,7 @@ const char* PerfDataManager::_name_spaces[] = {
};
PerfData::PerfData(CounterNS ns, const char* name, Units u, Variability v)
: _name(NULL), _u(u), _v(v), _valuep(NULL),
_on_c_heap(false) {
: _name(NULL), _v(v), _u(u), _on_c_heap(false), _valuep(NULL) {
const char* prefix = PerfDataManager::ns_to_string(ns);

@ -614,8 +614,7 @@ private:
public:
ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
_counters(counters),
_nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()) {}
_nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()), _counters(counters) {}
void do_thread(Thread* thread) {
ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
@ -636,9 +635,9 @@ private:
public:
ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
AbstractGangTask("Parallel Safepoint Cleanup"),
_subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
_cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
_num_workers(num_workers),
_subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
_counters(counters) {}
void work(uint worker_id) {

@ -414,8 +414,8 @@ class VM_FindDeadlocks: public VM_Operation {
// which protects the JavaThreads in _deadlocks.
public:
VM_FindDeadlocks(bool concurrent_locks) : _concurrent_locks(concurrent_locks), _out(NULL), _deadlocks(NULL), _setter() {};
VM_FindDeadlocks(outputStream* st) : _concurrent_locks(true), _out(st), _deadlocks(NULL) {};
VM_FindDeadlocks(bool concurrent_locks) : _concurrent_locks(concurrent_locks), _deadlocks(NULL), _out(NULL), _setter() {};
VM_FindDeadlocks(outputStream* st) : _concurrent_locks(true), _deadlocks(NULL), _out(st) {};
~VM_FindDeadlocks();
DeadlockCycle* result() { return _deadlocks; };

@ -560,10 +560,10 @@ int ClassHistogramDCmd::num_arguments() {
#define DEFAULT_COLUMNS "InstBytes,KlassBytes,CpAll,annotations,MethodCount,Bytecodes,MethodAll,ROAll,RWAll,Total"
ClassStatsDCmd::ClassStatsDCmd(outputStream* output, bool heap) :
DCmdWithParser(output, heap),
_csv("-csv", "Print in CSV (comma-separated values) format for spreadsheets",
"BOOLEAN", false, "false"),
_all("-all", "Show all columns",
"BOOLEAN", false, "false"),
_csv("-csv", "Print in CSV (comma-separated values) format for spreadsheets",
"BOOLEAN", false, "false"),
_help("-help", "Show meaning of all the columns",
"BOOLEAN", false, "false"),
_columns("columns", "Comma-separated list of all the columns to show. "

@ -50,7 +50,7 @@ class HeapDumper : public StackObj {
elapsedTimer _t;
HeapDumper(bool gc_before_heap_dump, bool print_to_tty, bool oome) :
_gc_before_heap_dump(gc_before_heap_dump), _error(NULL), _print_to_tty(print_to_tty), _oome(oome) { }
_error(NULL), _print_to_tty(print_to_tty), _gc_before_heap_dump(gc_before_heap_dump), _oome(oome) { }
// string representation of error
char* error() const { return _error; }
@ -66,7 +66,7 @@ class HeapDumper : public StackObj {
public:
HeapDumper(bool gc_before_heap_dump) :
_gc_before_heap_dump(gc_before_heap_dump), _error(NULL), _print_to_tty(false), _oome(false) { }
_error(NULL), _print_to_tty(false), _gc_before_heap_dump(gc_before_heap_dump), _oome(false) { }
~HeapDumper();

@ -146,7 +146,7 @@ class MallocSiteTable : AllStatic {
volatile int* _lock;
public:
AccessLock(volatile int* lock) :
_lock(lock), _lock_state(NoLock) {
_lock_state(NoLock), _lock(lock) {
}
~AccessLock() {

@ -88,8 +88,8 @@ class MemBaseline {
public:
// create a memory baseline
MemBaseline():
_baseline_type(Not_baselined),
_instance_class_count(0), _array_class_count(0) {
_instance_class_count(0), _array_class_count(0),
_baseline_type(Not_baselined) {
}
bool baseline(bool summaryOnly = true);

@ -421,7 +421,7 @@ DeadlockCycle* ThreadService::find_deadlocks_at_safepoint(ThreadsList * t_list,
return deadlocks;
}
ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(NULL), _next(NULL), _last(NULL), _setter() {
ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(NULL), _last(NULL), _next(NULL), _setter() {
// Create a new ThreadDumpResult object and append to the list.
// If GC happens before this function returns, Method*
@ -429,7 +429,7 @@ ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snap
ThreadService::add_thread_dump(this);
}
ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(NULL), _next(NULL), _last(NULL), _setter() {
ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(NULL), _last(NULL), _next(NULL), _setter() {
// Create a new ThreadDumpResult object and append to the list.
// If GC happens before this function returns, oops
// will be visited.

@ -213,8 +213,9 @@ private:
public:
// Dummy snapshot
ThreadSnapshot() : _thread(NULL), _threadObj(NULL), _stack_trace(NULL), _concurrent_locks(NULL), _next(NULL),
_blocker_object(NULL), _blocker_object_owner(NULL) {};
ThreadSnapshot() : _thread(NULL), _threadObj(NULL),
_blocker_object(NULL), _blocker_object_owner(NULL),
_stack_trace(NULL), _concurrent_locks(NULL), _next(NULL) {};
ThreadSnapshot(ThreadsList * t_list, JavaThread* thread);
~ThreadSnapshot();
@ -560,7 +561,7 @@ class JavaThreadBlockedOnMonitorEnterState : public JavaThreadStatusChanger {
}
JavaThreadBlockedOnMonitorEnterState(JavaThread *java_thread, ObjectMonitor *obj_m) :
_stat(NULL), _active(false), JavaThreadStatusChanger(java_thread) {
JavaThreadStatusChanger(java_thread), _stat(NULL), _active(false) {
assert((java_thread != NULL), "Java thread should not be null here");
// Change thread status and collect contended enter stats for monitor contended
// enter done for external java world objects and it is contended. All other cases

@ -999,8 +999,8 @@ inline size_t ConcurrentHashTable<VALUE, CONFIG, F>::
template <typename VALUE, typename CONFIG, MEMFLAGS F>
inline ConcurrentHashTable<VALUE, CONFIG, F>::
ConcurrentHashTable(size_t log2size, size_t log2size_limit, size_t grow_hint)
: _new_table(NULL), _log2_start_size(log2size),
_log2_size_limit(log2size_limit), _grow_hint(grow_hint),
: _new_table(NULL), _log2_size_limit(log2size_limit),
_log2_start_size(log2size), _grow_hint(grow_hint),
_size_limit_reached(false), _resize_lock_owner(NULL),
_invisible_epoch(0)
{

@ -48,8 +48,8 @@ class ConcurrentHashTable<VALUE, CONFIG, F>::BucketsOperation {
bool _is_mt;
BucketsOperation(ConcurrentHashTable<VALUE, CONFIG, F>* cht, bool is_mt = false)
: _cht(cht), _is_mt(is_mt), _next_to_claim(0), _task_size_log2(DEFAULT_TASK_SIZE_LOG2),
_stop_task(0), _size_log2(0) {}
: _cht(cht), _next_to_claim(0), _task_size_log2(DEFAULT_TASK_SIZE_LOG2),
_stop_task(0), _size_log2(0), _is_mt(is_mt) {}
// Returns true if you succeeded to claim the range start -> (stop-1).
bool claim(size_t* start, size_t* stop) {

@ -106,9 +106,9 @@ MarkedFileReader::~MarkedFileReader() {
}
ElfFile::ElfFile(const char* filepath) :
_string_tables(NULL), _symbol_tables(NULL), _funcDesc_table(NULL),
_next(NULL), _status(NullDecoder::no_error),
_shdr_string_table(NULL), _file(NULL), _filepath(NULL) {
_next(NULL), _filepath(NULL), _file(NULL),
_symbol_tables(NULL), _string_tables(NULL), _shdr_string_table(NULL), _funcDesc_table(NULL),
_status(NullDecoder::no_error) {
memset(&_elfHdr, 0, sizeof(_elfHdr));
int len = strlen(filepath) + 1;

@ -31,7 +31,7 @@
#include "utilities/elfFuncDescTable.hpp"
ElfFuncDescTable::ElfFuncDescTable(FILE* file, Elf_Shdr shdr, int index) :
_file(file), _index(index), _section(file, shdr) {
_section(file, shdr), _file(file), _index(index) {
assert(file, "null file handle");
// The actual function address (i.e. function entry point) is always the
// first value in the function descriptor (on IA64 and PPC64 they look as follows):

@ -34,7 +34,7 @@
// We will try to load whole string table into memory if we can.
// Otherwise, fallback to more expensive file operation.
ElfStringTable::ElfStringTable(FILE* const file, Elf_Shdr& shdr, int index) :
_section(file, shdr), _index(index), _fd(file), _next(NULL) {
_next(NULL), _index(index), _section(file, shdr), _fd(file) {
_status = _section.status();
}

@ -31,7 +31,7 @@
#include "utilities/elfSymbolTable.hpp"
ElfSymbolTable::ElfSymbolTable(FILE* const file, Elf_Shdr& shdr) :
_section(file, shdr), _fd(file), _next(NULL) {
_next(NULL), _fd(file), _section(file, shdr) {
assert(file != NULL, "null file handle");
_status = _section.status();

@ -86,11 +86,11 @@ template <class T> class EventLogBase : public EventLog {
public:
EventLogBase<T>(const char* name, int length = LogEventsBufferEntries):
_mutex(Mutex::event, name, false, Monitor::_safepoint_check_never),
_name(name),
_length(length),
_count(0),
_index(0),
_mutex(Mutex::event, name, false, Monitor::_safepoint_check_never) {
_count(0) {
_records = new EventRecord<T>[length];
}

@ -42,8 +42,8 @@ const char* strchrnul_(const char *s, int c) {
}
JSON::JSON(const char* text, bool silent, outputStream* st)
: start(text), pos(text), mark(text),
level(0), line(1), column(0), silent(silent), _valid(true), _st(st)
: _st(st), start(text), pos(text), mark(text),
level(0), line(1), column(0), silent(silent), _valid(true)
{
}

@ -104,7 +104,7 @@ double AbsSeq::dsd() const {
}
NumberSeq::NumberSeq(double alpha) :
AbsSeq(alpha), _maximum(0.0), _last(0.0) {
AbsSeq(alpha), _last(0.0), _maximum(0.0) {
}
bool NumberSeq::check_nums(NumberSeq *total, int n, NumberSeq **parts) {

@ -33,8 +33,8 @@
template <MEMFLAGS F> StackBase<F>::StackBase(size_t segment_size, size_t max_cache_size,
size_t max_size):
_seg_size(segment_size),
_max_cache_size(max_cache_size),
_max_size(adjust_max_size(max_size, segment_size))
_max_size(adjust_max_size(max_size, segment_size)),
_max_cache_size(max_cache_size)
{
assert(_max_size % _seg_size == 0, "not a multiple");
}

@ -32,7 +32,7 @@
#include "unittest.hpp"
#include "utilities/ostream.hpp"
LogTestFixture::LogTestFixture() : _configuration_snapshot(NULL), _n_snapshots(0) {
LogTestFixture::LogTestFixture() : _n_snapshots(0), _configuration_snapshot(NULL) {
// Set up TestLogFileName to include PID, testcase name and test name
int ret = jio_snprintf(_filename, sizeof(_filename), "testlog.pid%d.%s.%s.log",
os::current_process_id(),

@ -85,7 +85,7 @@ struct ValVerify {
uintptr_t _val;
bool called_get;
bool called_insert;
ValVerify(uintptr_t val) : called_get(false), called_insert(false), _val(val) {}
ValVerify(uintptr_t val) : _val(val), called_get(false), called_insert(false) {}
void operator()(bool inserted, uintptr_t* val) {
EXPECT_EQ(_val, *val) << "The value inserted is not correct.";
if (inserted) {