mirror of
https://github.com/openjdk/jdk.git
synced 2025-09-24 04:54:40 +02:00
Merge
This commit is contained in:
Jesper Wilhelmsson
commit
43ff2913a7
71 changed files with 1662 additions and 662 deletions
|
|
@ -944,6 +944,8 @@ void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char*
|
|||
MINIDUMP_TYPE dumpType;
|
||||
static const char* cwd;
|
||||
|
||||
// Default is to always create dump for debug builds, on product builds only dump on server versions of Windows.
|
||||
#ifndef ASSERT
|
||||
// If running on a client version of Windows and user has not explicitly enabled dumping
|
||||
if (!os::win32::is_windows_server() && !CreateMinidumpOnCrash) {
|
||||
VMError::report_coredump_status("Minidumps are not enabled by default on client versions of Windows", false);
|
||||
|
|
@ -953,6 +955,12 @@ void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char*
|
|||
VMError::report_coredump_status("Minidump has been disabled from the command line", false);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
if (!FLAG_IS_DEFAULT(CreateMinidumpOnCrash) && !CreateMinidumpOnCrash) {
|
||||
VMError::report_coredump_status("Minidump has been disabled from the command line", false);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
dbghelp = os::win32::load_Windows_dll("DBGHELP.DLL", NULL, 0);
|
||||
|
||||
|
|
@ -1004,7 +1012,21 @@ void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char*
|
|||
// the dump types we really want. If first call fails, lets fall back to just use MiniDumpWithFullMemory then.
|
||||
if (_MiniDumpWriteDump(hProcess, processId, dumpFile, dumpType, pmei, NULL, NULL) == false &&
|
||||
_MiniDumpWriteDump(hProcess, processId, dumpFile, (MINIDUMP_TYPE)MiniDumpWithFullMemory, pmei, NULL, NULL) == false) {
|
||||
VMError::report_coredump_status("Call to MiniDumpWriteDump() failed", false);
|
||||
DWORD error = GetLastError();
|
||||
LPTSTR msgbuf = NULL;
|
||||
|
||||
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||
NULL, error, 0, (LPTSTR)&msgbuf, 0, NULL) != 0) {
|
||||
|
||||
jio_snprintf(buffer, bufferSize, "Call to MiniDumpWriteDump() failed (Error 0x%x: %s)", error, msgbuf);
|
||||
LocalFree(msgbuf);
|
||||
} else {
|
||||
// Call to FormatMessage failed, just include the result from GetLastError
|
||||
jio_snprintf(buffer, bufferSize, "Call to MiniDumpWriteDump() failed (Error 0x%x)", error);
|
||||
}
|
||||
VMError::report_coredump_status(buffer, false);
|
||||
} else {
|
||||
VMError::report_coredump_status(buffer, true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -444,8 +444,8 @@ constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
|
|||
break;
|
||||
case JVM_REF_invokeStatic:
|
||||
case JVM_REF_invokeSpecial:
|
||||
check_property(
|
||||
tag.is_method() || tag.is_interface_method(),
|
||||
check_property(tag.is_method() ||
|
||||
((_major_version >= JAVA_8_VERSION) && tag.is_interface_method()),
|
||||
"Invalid constant pool index %u in class file %s (not a method)",
|
||||
ref_index, CHECK_(nullHandle));
|
||||
break;
|
||||
|
|
@ -3152,7 +3152,6 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
}
|
||||
}
|
||||
}
|
||||
int contended_count = nonstatic_contended_count;
|
||||
|
||||
|
||||
// Calculate the starting byte offsets
|
||||
|
|
@ -3177,35 +3176,52 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
|
||||
next_nonstatic_field_offset = nonstatic_fields_start;
|
||||
|
||||
bool is_contended_class = parsed_annotations->is_contended();
|
||||
|
||||
// Class is contended, pad before all the fields
|
||||
if (parsed_annotations->is_contended()) {
|
||||
if (is_contended_class) {
|
||||
next_nonstatic_field_offset += ContendedPaddingWidth;
|
||||
}
|
||||
|
||||
// Compute the non-contended fields count
|
||||
// Compute the non-contended fields count.
|
||||
// The packing code below relies on these counts to determine if some field
|
||||
// can be squeezed into the alignment gap. Contended fields are obviously
|
||||
// exempt from that.
|
||||
unsigned int nonstatic_double_count = fac->count[NONSTATIC_DOUBLE] - fac_contended.count[NONSTATIC_DOUBLE];
|
||||
unsigned int nonstatic_word_count = fac->count[NONSTATIC_WORD] - fac_contended.count[NONSTATIC_WORD];
|
||||
unsigned int nonstatic_short_count = fac->count[NONSTATIC_SHORT] - fac_contended.count[NONSTATIC_SHORT];
|
||||
unsigned int nonstatic_byte_count = fac->count[NONSTATIC_BYTE] - fac_contended.count[NONSTATIC_BYTE];
|
||||
unsigned int nonstatic_oop_count = fac->count[NONSTATIC_OOP] - fac_contended.count[NONSTATIC_OOP];
|
||||
|
||||
// Total non-static fields count, including every contended field
|
||||
unsigned int nonstatic_fields_count = fac->count[NONSTATIC_DOUBLE] + fac->count[NONSTATIC_WORD] +
|
||||
fac->count[NONSTATIC_SHORT] + fac->count[NONSTATIC_BYTE] +
|
||||
fac->count[NONSTATIC_OOP];
|
||||
|
||||
bool super_has_nonstatic_fields =
|
||||
(_super_klass() != NULL && _super_klass->has_nonstatic_fields());
|
||||
bool has_nonstatic_fields = super_has_nonstatic_fields ||
|
||||
((nonstatic_double_count + nonstatic_word_count +
|
||||
nonstatic_short_count + nonstatic_byte_count +
|
||||
nonstatic_oop_count) != 0);
|
||||
bool has_nonstatic_fields = super_has_nonstatic_fields || (nonstatic_fields_count != 0);
|
||||
|
||||
|
||||
// Prepare list of oops for oop map generation.
|
||||
//
|
||||
// "offset" and "count" lists are describing the set of contiguous oop
|
||||
// regions. offset[i] is the start of the i-th region, which then has
|
||||
// count[i] oops following. Before we know how many regions are required,
|
||||
// we pessimistically allocate the maps to fit all the oops into the
|
||||
// distinct regions.
|
||||
//
|
||||
// TODO: We add +1 to always allocate non-zero resource arrays; we need
|
||||
// to figure out if we still need to do this.
|
||||
int* nonstatic_oop_offsets;
|
||||
unsigned int* nonstatic_oop_counts;
|
||||
unsigned int nonstatic_oop_map_count = 0;
|
||||
unsigned int max_nonstatic_oop_maps = fac->count[NONSTATIC_OOP] + 1;
|
||||
|
||||
nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
|
||||
THREAD, int, nonstatic_oop_count + 1);
|
||||
THREAD, int, max_nonstatic_oop_maps);
|
||||
nonstatic_oop_counts = NEW_RESOURCE_ARRAY_IN_THREAD(
|
||||
THREAD, unsigned int, nonstatic_oop_count + 1);
|
||||
THREAD, unsigned int, max_nonstatic_oop_maps);
|
||||
|
||||
first_nonstatic_oop_offset = 0; // will be set for first oop field
|
||||
|
||||
|
|
@ -3392,9 +3408,11 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) *
|
||||
heapOopSize ) {
|
||||
// Extend current oop map
|
||||
assert(nonstatic_oop_map_count - 1 < max_nonstatic_oop_maps, "range check");
|
||||
nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1;
|
||||
} else {
|
||||
// Create new oop map
|
||||
assert(nonstatic_oop_map_count < max_nonstatic_oop_maps, "range check");
|
||||
nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
|
||||
nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
|
||||
nonstatic_oop_map_count += 1;
|
||||
|
|
@ -3452,12 +3470,10 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
//
|
||||
// Additionally, this should not break alignment for the fields, so we round the alignment up
|
||||
// for each field.
|
||||
if (contended_count > 0) {
|
||||
if (nonstatic_contended_count > 0) {
|
||||
|
||||
// if there is at least one contended field, we need to have pre-padding for them
|
||||
if (nonstatic_contended_count > 0) {
|
||||
next_nonstatic_padded_offset += ContendedPaddingWidth;
|
||||
}
|
||||
next_nonstatic_padded_offset += ContendedPaddingWidth;
|
||||
|
||||
// collect all contended groups
|
||||
BitMap bm(_cp->size());
|
||||
|
|
@ -3518,6 +3534,7 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
next_nonstatic_padded_offset += heapOopSize;
|
||||
|
||||
// Create new oop map
|
||||
assert(nonstatic_oop_map_count < max_nonstatic_oop_maps, "range check");
|
||||
nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
|
||||
nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
|
||||
nonstatic_oop_map_count += 1;
|
||||
|
|
@ -3554,18 +3571,17 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
// handle static fields
|
||||
}
|
||||
|
||||
// Size of instances
|
||||
int notaligned_offset = next_nonstatic_padded_offset;
|
||||
|
||||
// Entire class is contended, pad in the back.
|
||||
// This helps to alleviate memory contention effects for subclass fields
|
||||
// and/or adjacent object.
|
||||
if (parsed_annotations->is_contended()) {
|
||||
notaligned_offset += ContendedPaddingWidth;
|
||||
if (is_contended_class) {
|
||||
next_nonstatic_padded_offset += ContendedPaddingWidth;
|
||||
}
|
||||
|
||||
int nonstatic_fields_end = align_size_up(notaligned_offset, heapOopSize);
|
||||
int instance_end = align_size_up(notaligned_offset, wordSize);
|
||||
int notaligned_nonstatic_fields_end = next_nonstatic_padded_offset;
|
||||
|
||||
int nonstatic_fields_end = align_size_up(notaligned_nonstatic_fields_end, heapOopSize);
|
||||
int instance_end = align_size_up(notaligned_nonstatic_fields_end, wordSize);
|
||||
int static_fields_end = align_size_up(next_static_byte_offset, wordSize);
|
||||
|
||||
int static_field_size = (static_fields_end -
|
||||
|
|
@ -3579,6 +3595,14 @@ void ClassFileParser::layout_fields(Handle class_loader,
|
|||
(instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize),
|
||||
wordSize) / wordSize), "consistent layout helper value");
|
||||
|
||||
// Invariant: nonstatic_field end/start should only change if there are
|
||||
// nonstatic fields in the class, or if the class is contended. We compare
|
||||
// against the non-aligned value, so that end alignment will not fail the
|
||||
// assert without actually having the fields.
|
||||
assert((notaligned_nonstatic_fields_end == nonstatic_fields_start) ||
|
||||
is_contended_class ||
|
||||
(nonstatic_fields_count > 0), "double-check nonstatic start/end");
|
||||
|
||||
// Number of non-static oop map blocks allocated at end of klass.
|
||||
const unsigned int total_oop_map_count =
|
||||
compute_oop_map_count(_super_klass, nonstatic_oop_map_count,
|
||||
|
|
@ -4040,6 +4064,9 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
|
|||
}
|
||||
}
|
||||
|
||||
// Allocate mirror and initialize static fields
|
||||
java_lang_Class::create_mirror(this_klass, protection_domain, CHECK_(nullHandle));
|
||||
|
||||
|
||||
#ifdef ASSERT
|
||||
if (ParseAllGenericSignatures) {
|
||||
|
|
@ -4055,17 +4082,6 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
|
|||
this_klass(), &all_mirandas, CHECK_(nullHandle));
|
||||
}
|
||||
|
||||
// Allocate mirror and initialize static fields
|
||||
java_lang_Class::create_mirror(this_klass, CHECK_(nullHandle));
|
||||
|
||||
// Allocate a simple java object for locking during class initialization.
|
||||
// This needs to be a java object because it can be held across a java call.
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK_NULL);
|
||||
this_klass->set_init_lock(r);
|
||||
|
||||
// TODO: Move these oops to the mirror
|
||||
this_klass->set_protection_domain(protection_domain());
|
||||
|
||||
// Update the loader_data graph.
|
||||
record_defined_class_dependencies(this_klass, CHECK_NULL);
|
||||
|
||||
|
|
|
|||
|
|
@ -512,22 +512,22 @@ void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
|
|||
|
||||
// If the offset was read from the shared archive, it was fixed up already
|
||||
if (!k->is_shared()) {
|
||||
if (k->oop_is_instance()) {
|
||||
// During bootstrap, java.lang.Class wasn't loaded so static field
|
||||
// offsets were computed without the size added it. Go back and
|
||||
// update all the static field offsets to included the size.
|
||||
for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) {
|
||||
if (fs.access_flags().is_static()) {
|
||||
int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields();
|
||||
fs.set_offset(real_offset);
|
||||
if (k->oop_is_instance()) {
|
||||
// During bootstrap, java.lang.Class wasn't loaded so static field
|
||||
// offsets were computed without the size added it. Go back and
|
||||
// update all the static field offsets to included the size.
|
||||
for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) {
|
||||
if (fs.access_flags().is_static()) {
|
||||
int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields();
|
||||
fs.set_offset(real_offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
create_mirror(k, CHECK);
|
||||
create_mirror(k, Handle(NULL), CHECK);
|
||||
}
|
||||
|
||||
oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
|
||||
oop java_lang_Class::create_mirror(KlassHandle k, Handle protection_domain, TRAPS) {
|
||||
assert(k->java_mirror() == NULL, "should only assign mirror once");
|
||||
// Use this moment of initialization to cache modifier_flags also,
|
||||
// to support Class.getModifiers(). Instance classes recalculate
|
||||
|
|
@ -563,6 +563,16 @@ oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
|
|||
set_array_klass(comp_mirror(), k());
|
||||
} else {
|
||||
assert(k->oop_is_instance(), "Must be");
|
||||
|
||||
// Allocate a simple java object for a lock.
|
||||
// This needs to be a java object because during class initialization
|
||||
// it can be held across a java call.
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK_NULL);
|
||||
set_init_lock(mirror(), r);
|
||||
|
||||
// Set protection domain also
|
||||
set_protection_domain(mirror(), protection_domain());
|
||||
|
||||
// Initialize static fields
|
||||
InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
|
||||
}
|
||||
|
|
@ -597,6 +607,34 @@ void java_lang_Class::set_static_oop_field_count(oop java_class, int size) {
|
|||
java_class->int_field_put(_static_oop_field_count_offset, size);
|
||||
}
|
||||
|
||||
oop java_lang_Class::protection_domain(oop java_class) {
|
||||
assert(_protection_domain_offset != 0, "must be set");
|
||||
return java_class->obj_field(_protection_domain_offset);
|
||||
}
|
||||
void java_lang_Class::set_protection_domain(oop java_class, oop pd) {
|
||||
assert(_protection_domain_offset != 0, "must be set");
|
||||
java_class->obj_field_put(_protection_domain_offset, pd);
|
||||
}
|
||||
|
||||
oop java_lang_Class::init_lock(oop java_class) {
|
||||
assert(_init_lock_offset != 0, "must be set");
|
||||
return java_class->obj_field(_init_lock_offset);
|
||||
}
|
||||
void java_lang_Class::set_init_lock(oop java_class, oop init_lock) {
|
||||
assert(_init_lock_offset != 0, "must be set");
|
||||
java_class->obj_field_put(_init_lock_offset, init_lock);
|
||||
}
|
||||
|
||||
objArrayOop java_lang_Class::signers(oop java_class) {
|
||||
assert(_signers_offset != 0, "must be set");
|
||||
return (objArrayOop)java_class->obj_field(_signers_offset);
|
||||
}
|
||||
void java_lang_Class::set_signers(oop java_class, objArrayOop signers) {
|
||||
assert(_signers_offset != 0, "must be set");
|
||||
java_class->obj_field_put(_signers_offset, (oop)signers);
|
||||
}
|
||||
|
||||
|
||||
oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
|
||||
// This should be improved by adding a field at the Java level or by
|
||||
// introducing a new VM klass (see comment in ClassFileParser)
|
||||
|
|
@ -2934,6 +2972,9 @@ int java_lang_Class::_klass_offset;
|
|||
int java_lang_Class::_array_klass_offset;
|
||||
int java_lang_Class::_oop_size_offset;
|
||||
int java_lang_Class::_static_oop_field_count_offset;
|
||||
int java_lang_Class::_protection_domain_offset;
|
||||
int java_lang_Class::_init_lock_offset;
|
||||
int java_lang_Class::_signers_offset;
|
||||
GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
|
||||
int java_lang_Throwable::backtrace_offset;
|
||||
int java_lang_Throwable::detailMessage_offset;
|
||||
|
|
|
|||
|
|
@ -208,7 +208,10 @@ class java_lang_String : AllStatic {
|
|||
macro(java_lang_Class, klass, intptr_signature, false) \
|
||||
macro(java_lang_Class, array_klass, intptr_signature, false) \
|
||||
macro(java_lang_Class, oop_size, int_signature, false) \
|
||||
macro(java_lang_Class, static_oop_field_count, int_signature, false)
|
||||
macro(java_lang_Class, static_oop_field_count, int_signature, false) \
|
||||
macro(java_lang_Class, protection_domain, object_signature, false) \
|
||||
macro(java_lang_Class, init_lock, object_signature, false) \
|
||||
macro(java_lang_Class, signers, object_signature, false)
|
||||
|
||||
class java_lang_Class : AllStatic {
|
||||
friend class VMStructs;
|
||||
|
|
@ -222,15 +225,20 @@ class java_lang_Class : AllStatic {
|
|||
static int _oop_size_offset;
|
||||
static int _static_oop_field_count_offset;
|
||||
|
||||
static int _protection_domain_offset;
|
||||
static int _init_lock_offset;
|
||||
static int _signers_offset;
|
||||
|
||||
static bool offsets_computed;
|
||||
static int classRedefinedCount_offset;
|
||||
static GrowableArray<Klass*>* _fixup_mirror_list;
|
||||
|
||||
static void set_init_lock(oop java_class, oop init_lock);
|
||||
public:
|
||||
static void compute_offsets();
|
||||
|
||||
// Instance creation
|
||||
static oop create_mirror(KlassHandle k, TRAPS);
|
||||
static oop create_mirror(KlassHandle k, Handle protection_domain, TRAPS);
|
||||
static void fixup_mirror(KlassHandle k, TRAPS);
|
||||
static oop create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS);
|
||||
// Conversion
|
||||
|
|
@ -262,6 +270,13 @@ class java_lang_Class : AllStatic {
|
|||
static int classRedefinedCount(oop the_class_mirror);
|
||||
static void set_classRedefinedCount(oop the_class_mirror, int value);
|
||||
|
||||
// Support for embedded per-class oops
|
||||
static oop protection_domain(oop java_class);
|
||||
static void set_protection_domain(oop java_class, oop protection_domain);
|
||||
static oop init_lock(oop java_class);
|
||||
static objArrayOop signers(oop java_class);
|
||||
static void set_signers(oop java_class, objArrayOop signers);
|
||||
|
||||
static int oop_size(oop java_class);
|
||||
static void set_oop_size(oop java_class, int size);
|
||||
static int static_oop_field_count(oop java_class);
|
||||
|
|
|
|||
|
|
@ -392,6 +392,9 @@
|
|||
template(array_klass_name, "array_klass") \
|
||||
template(oop_size_name, "oop_size") \
|
||||
template(static_oop_field_count_name, "static_oop_field_count") \
|
||||
template(protection_domain_name, "protection_domain") \
|
||||
template(init_lock_name, "init_lock") \
|
||||
template(signers_name, "signers_name") \
|
||||
template(loader_data_name, "loader_data") \
|
||||
template(dependencies_name, "dependencies") \
|
||||
\
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ void ArrayKlass::complete_create_array_klass(ArrayKlass* k, KlassHandle super_kl
|
|||
ResourceMark rm(THREAD);
|
||||
k->initialize_supers(super_klass(), CHECK);
|
||||
k->vtable()->initialize_vtable(false, CHECK);
|
||||
java_lang_Class::create_mirror(k, CHECK);
|
||||
java_lang_Class::create_mirror(k, Handle(NULL), CHECK);
|
||||
}
|
||||
|
||||
GrowableArray<Klass*>* ArrayKlass::compute_secondary_supers(int num_extra_slots) {
|
||||
|
|
|
|||
|
|
@ -1063,9 +1063,10 @@ bool ConstantPool::compare_entry_to(int index1, constantPoolHandle cp2,
|
|||
int k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
|
||||
int i1 = invoke_dynamic_bootstrap_specifier_index(index1);
|
||||
int i2 = cp2->invoke_dynamic_bootstrap_specifier_index(index2);
|
||||
bool match = compare_entry_to(k1, cp2, k2, CHECK_false) &&
|
||||
compare_operand_to(i1, cp2, i2, CHECK_false);
|
||||
return match;
|
||||
// separate statements and variables because CHECK_false is used
|
||||
bool match_entry = compare_entry_to(k1, cp2, k2, CHECK_false);
|
||||
bool match_operand = compare_operand_to(i1, cp2, i2, CHECK_false);
|
||||
return (match_entry && match_operand);
|
||||
} break;
|
||||
|
||||
case JVM_CONSTANT_String:
|
||||
|
|
|
|||
|
|
@ -268,8 +268,6 @@ InstanceKlass::InstanceKlass(int vtable_len,
|
|||
set_fields(NULL, 0);
|
||||
set_constants(NULL);
|
||||
set_class_loader_data(NULL);
|
||||
set_protection_domain(NULL);
|
||||
set_signers(NULL);
|
||||
set_source_file_name(NULL);
|
||||
set_source_debug_extension(NULL, 0);
|
||||
set_array_name(NULL);
|
||||
|
|
@ -279,7 +277,6 @@ InstanceKlass::InstanceKlass(int vtable_len,
|
|||
set_is_marked_dependent(false);
|
||||
set_init_state(InstanceKlass::allocated);
|
||||
set_init_thread(NULL);
|
||||
set_init_lock(NULL);
|
||||
set_reference_type(rt);
|
||||
set_oop_map_cache(NULL);
|
||||
set_jni_ids(NULL);
|
||||
|
|
@ -408,12 +405,6 @@ void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) {
|
|||
}
|
||||
set_inner_classes(NULL);
|
||||
|
||||
// Null out Java heap objects, although these won't be walked to keep
|
||||
// alive once this InstanceKlass is deallocated.
|
||||
set_protection_domain(NULL);
|
||||
set_signers(NULL);
|
||||
set_init_lock(NULL);
|
||||
|
||||
// We should deallocate the Annotations instance
|
||||
MetadataFactory::free_metadata(loader_data, annotations());
|
||||
set_annotations(NULL);
|
||||
|
|
@ -451,6 +442,24 @@ void InstanceKlass::eager_initialize(Thread *thread) {
|
|||
}
|
||||
}
|
||||
|
||||
// JVMTI spec thinks there are signers and protection domain in the
|
||||
// instanceKlass. These accessors pretend these fields are there.
|
||||
// The hprof specification also thinks these fields are in InstanceKlass.
|
||||
oop InstanceKlass::protection_domain() const {
|
||||
// return the protection_domain from the mirror
|
||||
return java_lang_Class::protection_domain(java_mirror());
|
||||
}
|
||||
|
||||
// To remove these from requires an incompatible change and CCC request.
|
||||
objArrayOop InstanceKlass::signers() const {
|
||||
// return the signers from the mirror
|
||||
return java_lang_Class::signers(java_mirror());
|
||||
}
|
||||
|
||||
volatile oop InstanceKlass::init_lock() const {
|
||||
// return the init lock from the mirror
|
||||
return java_lang_Class::init_lock(java_mirror());
|
||||
}
|
||||
|
||||
void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {
|
||||
EXCEPTION_MARK;
|
||||
|
|
@ -1883,16 +1892,6 @@ bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
|
|||
|
||||
// Garbage collection
|
||||
|
||||
void InstanceKlass::oops_do(OopClosure* cl) {
|
||||
Klass::oops_do(cl);
|
||||
|
||||
cl->do_oop(adr_protection_domain());
|
||||
cl->do_oop(adr_signers());
|
||||
cl->do_oop(adr_init_lock());
|
||||
|
||||
// Don't walk the arrays since they are walked from the ClassLoaderData objects.
|
||||
}
|
||||
|
||||
#ifdef ASSERT
|
||||
template <class T> void assert_is_in(T *p) {
|
||||
T heap_oop = oopDesc::load_heap_oop(p);
|
||||
|
|
@ -2241,9 +2240,6 @@ void InstanceKlass::remove_unshareable_info() {
|
|||
m->remove_unshareable_info();
|
||||
}
|
||||
|
||||
// Need to reinstate when reading back the class.
|
||||
set_init_lock(NULL);
|
||||
|
||||
// do array classes also.
|
||||
array_klasses_do(remove_unshareable_in_class);
|
||||
}
|
||||
|
|
@ -2275,13 +2271,6 @@ void InstanceKlass::restore_unshareable_info(TRAPS) {
|
|||
ik->itable()->initialize_itable(false, CHECK);
|
||||
}
|
||||
|
||||
// Allocate a simple java object for a lock.
|
||||
// This needs to be a java object because during class initialization
|
||||
// it can be held across a java call.
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK);
|
||||
Handle h(THREAD, (oop)r);
|
||||
ik->set_init_lock(h());
|
||||
|
||||
// restore constant pool resolved references
|
||||
ik->constants()->restore_unshareable_info(CHECK);
|
||||
|
||||
|
|
@ -2331,10 +2320,15 @@ void InstanceKlass::release_C_heap_structures() {
|
|||
FreeHeap(jmeths);
|
||||
}
|
||||
|
||||
MemberNameTable* mnt = member_names();
|
||||
if (mnt != NULL) {
|
||||
delete mnt;
|
||||
set_member_names(NULL);
|
||||
// Deallocate MemberNameTable
|
||||
{
|
||||
Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock;
|
||||
MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag);
|
||||
MemberNameTable* mnt = member_names();
|
||||
if (mnt != NULL) {
|
||||
delete mnt;
|
||||
set_member_names(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
int* indices = methods_cached_itable_indices_acquire();
|
||||
|
|
@ -2765,15 +2759,28 @@ nmethod* InstanceKlass::lookup_osr_nmethod(const Method* m, int bci, int comp_le
|
|||
return NULL;
|
||||
}
|
||||
|
||||
void InstanceKlass::add_member_name(Handle mem_name) {
|
||||
void InstanceKlass::add_member_name(int index, Handle mem_name) {
|
||||
jweak mem_name_wref = JNIHandles::make_weak_global(mem_name);
|
||||
MutexLocker ml(MemberNameTable_lock);
|
||||
assert(0 <= index && index < idnum_allocated_count(), "index is out of bounds");
|
||||
DEBUG_ONLY(No_Safepoint_Verifier nsv);
|
||||
|
||||
if (_member_names == NULL) {
|
||||
_member_names = new (ResourceObj::C_HEAP, mtClass) MemberNameTable();
|
||||
_member_names = new (ResourceObj::C_HEAP, mtClass) MemberNameTable(idnum_allocated_count());
|
||||
}
|
||||
_member_names->add_member_name(mem_name_wref);
|
||||
_member_names->add_member_name(index, mem_name_wref);
|
||||
}
|
||||
|
||||
oop InstanceKlass::get_member_name(int index) {
|
||||
MutexLocker ml(MemberNameTable_lock);
|
||||
assert(0 <= index && index < idnum_allocated_count(), "index is out of bounds");
|
||||
DEBUG_ONLY(No_Safepoint_Verifier nsv);
|
||||
|
||||
if (_member_names == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
oop mem_name =_member_names->get_member_name(index);
|
||||
return mem_name;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------------------------
|
||||
|
|
@ -2836,10 +2843,7 @@ void InstanceKlass::print_on(outputStream* st) const {
|
|||
class_loader_data()->print_value_on(st);
|
||||
st->cr();
|
||||
}
|
||||
st->print(BULLET"protection domain: "); ((InstanceKlass*)this)->protection_domain()->print_value_on(st); st->cr();
|
||||
st->print(BULLET"host class: "); host_klass()->print_value_on_maybe_null(st); st->cr();
|
||||
st->print(BULLET"signers: "); signers()->print_value_on(st); st->cr();
|
||||
st->print(BULLET"init_lock: "); ((oop)_init_lock)->print_value_on(st); st->cr();
|
||||
if (source_file_name() != NULL) {
|
||||
st->print(BULLET"source file: ");
|
||||
source_file_name()->print_value_on(st);
|
||||
|
|
@ -3040,7 +3044,6 @@ void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {
|
|||
n += (sz->_method_ordering_bytes = sz->count_array(method_ordering()));
|
||||
n += (sz->_local_interfaces_bytes = sz->count_array(local_interfaces()));
|
||||
n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces()));
|
||||
n += (sz->_signers_bytes = sz->count_array(signers()));
|
||||
n += (sz->_fields_bytes = sz->count_array(fields()));
|
||||
n += (sz->_inner_classes_bytes = sz->count_array(inner_classes()));
|
||||
sz->_ro_bytes += n;
|
||||
|
|
@ -3206,17 +3209,11 @@ void InstanceKlass::verify_on(outputStream* st) {
|
|||
guarantee(constants()->is_metadata(), "should be in metaspace");
|
||||
guarantee(constants()->is_constantPool(), "should be constant pool");
|
||||
}
|
||||
if (protection_domain() != NULL) {
|
||||
guarantee(protection_domain()->is_oop(), "should be oop");
|
||||
}
|
||||
const Klass* host = host_klass();
|
||||
if (host != NULL) {
|
||||
guarantee(host->is_metadata(), "should be in metaspace");
|
||||
guarantee(host->is_klass(), "should be klass");
|
||||
}
|
||||
if (signers() != NULL) {
|
||||
guarantee(signers()->is_objArray(), "should be obj array");
|
||||
}
|
||||
}
|
||||
|
||||
void InstanceKlass::oop_verify_on(oop obj, outputStream* st) {
|
||||
|
|
|
|||
|
|
@ -58,8 +58,6 @@
|
|||
// [fields ]
|
||||
// [constants ]
|
||||
// [class loader ]
|
||||
// [protection domain ]
|
||||
// [signers ]
|
||||
// [source file name ]
|
||||
// [inner classes ]
|
||||
// [static field size ]
|
||||
|
|
@ -180,16 +178,6 @@ class InstanceKlass: public Klass {
|
|||
static volatile int _total_instanceKlass_count;
|
||||
|
||||
protected:
|
||||
// Protection domain.
|
||||
oop _protection_domain;
|
||||
// Class signers.
|
||||
objArrayOop _signers;
|
||||
// Lock for (1) initialization; (2) access to the ConstantPool of this class.
|
||||
// Must be one per class and it has to be a VM internal object so java code
|
||||
// cannot lock it (like the mirror).
|
||||
// It has to be an object not a Mutex because it's held through java calls.
|
||||
volatile oop _init_lock;
|
||||
|
||||
// Annotations for this class
|
||||
Annotations* _annotations;
|
||||
// Array classes holding elements of this class.
|
||||
|
|
@ -527,8 +515,10 @@ class InstanceKlass: public Klass {
|
|||
void set_constants(ConstantPool* c) { _constants = c; }
|
||||
|
||||
// protection domain
|
||||
oop protection_domain() { return _protection_domain; }
|
||||
void set_protection_domain(oop pd) { klass_oop_store(&_protection_domain, pd); }
|
||||
oop protection_domain() const;
|
||||
|
||||
// signers
|
||||
objArrayOop signers() const;
|
||||
|
||||
// host class
|
||||
Klass* host_klass() const {
|
||||
|
|
@ -575,10 +565,6 @@ class InstanceKlass: public Klass {
|
|||
}
|
||||
}
|
||||
|
||||
// signers
|
||||
objArrayOop signers() const { return _signers; }
|
||||
void set_signers(objArrayOop s) { klass_oop_store((oop*)&_signers, s); }
|
||||
|
||||
// source file name
|
||||
Symbol* source_file_name() const { return _source_file_name; }
|
||||
void set_source_file_name(Symbol* n);
|
||||
|
|
@ -912,8 +898,6 @@ class InstanceKlass: public Klass {
|
|||
Method* method_at_itable(Klass* holder, int index, TRAPS);
|
||||
|
||||
// Garbage collection
|
||||
virtual void oops_do(OopClosure* cl);
|
||||
|
||||
void oop_follow_contents(oop obj);
|
||||
int oop_adjust_pointers(oop obj);
|
||||
|
||||
|
|
@ -999,14 +983,12 @@ private:
|
|||
|
||||
// Lock during initialization
|
||||
public:
|
||||
volatile oop init_lock() const {return _init_lock; }
|
||||
// Lock for (1) initialization; (2) access to the ConstantPool of this class.
|
||||
// Must be one per class and it has to be a VM internal object so java code
|
||||
// cannot lock it (like the mirror).
|
||||
// It has to be an object not a Mutex because it's held through java calls.
|
||||
volatile oop init_lock() const;
|
||||
private:
|
||||
void set_init_lock(oop value) { klass_oop_store(&_init_lock, value); }
|
||||
|
||||
// Offsets for memory management
|
||||
oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;}
|
||||
oop* adr_signers() const { return (oop*)&this->_signers;}
|
||||
oop* adr_init_lock() const { return (oop*)&this->_init_lock;}
|
||||
|
||||
// Static methods that are used to implement member methods where an exposed this pointer
|
||||
// is needed due to possible GCs
|
||||
|
|
@ -1040,7 +1022,8 @@ public:
|
|||
// JSR-292 support
|
||||
MemberNameTable* member_names() { return _member_names; }
|
||||
void set_member_names(MemberNameTable* member_names) { _member_names = member_names; }
|
||||
void add_member_name(Handle member_name);
|
||||
void add_member_name(int index, Handle member_name);
|
||||
oop get_member_name(int index);
|
||||
|
||||
public:
|
||||
// JVMTI support
|
||||
|
|
|
|||
|
|
@ -511,8 +511,9 @@ void Klass::restore_unshareable_info(TRAPS) {
|
|||
// (same order as class file parsing)
|
||||
loader_data->add_class(this);
|
||||
|
||||
// Recreate the class mirror
|
||||
java_lang_Class::create_mirror(this, CHECK);
|
||||
// Recreate the class mirror. The protection_domain is always null for
|
||||
// boot loader, for now.
|
||||
java_lang_Class::create_mirror(this, Handle(NULL), CHECK);
|
||||
}
|
||||
|
||||
Klass* Klass::array_klass_or_null(int rank) {
|
||||
|
|
|
|||
|
|
@ -445,7 +445,7 @@ class Klass : public Metadata {
|
|||
Klass* array_klass_or_null(int rank);
|
||||
Klass* array_klass_or_null();
|
||||
|
||||
virtual oop protection_domain() { return NULL; }
|
||||
virtual oop protection_domain() const = 0;
|
||||
|
||||
oop class_loader() const;
|
||||
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ class ObjArrayKlass : public ArrayKlass {
|
|||
void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
|
||||
|
||||
// Compute protection domain
|
||||
oop protection_domain() { return bottom_klass()->protection_domain(); }
|
||||
oop protection_domain() const { return bottom_klass()->protection_domain(); }
|
||||
|
||||
private:
|
||||
// Either oop or narrowOop depending on UseCompressedOops.
|
||||
|
|
|
|||
|
|
@ -67,6 +67,8 @@ class TypeArrayKlass : public ArrayKlass {
|
|||
typeArrayOop allocate(int length, TRAPS) { return allocate_common(length, true, THREAD); }
|
||||
oop multi_allocate(int rank, jint* sizes, TRAPS);
|
||||
|
||||
oop protection_domain() const { return NULL; }
|
||||
|
||||
// Copying
|
||||
void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
|
||||
|
||||
|
|
|
|||
|
|
@ -35,6 +35,19 @@
|
|||
#include "runtime/vframe.hpp"
|
||||
#include "runtime/vframeArray.hpp"
|
||||
|
||||
// call frame copied from old .h file and renamed
|
||||
typedef struct {
|
||||
jint lineno; // line number in the source file
|
||||
jmethodID method_id; // method executed in this frame
|
||||
} ASGCT_CallFrame;
|
||||
|
||||
// call trace copied from old .h file and renamed
|
||||
typedef struct {
|
||||
JNIEnv *env_id; // Env where trace was recorded
|
||||
jint num_frames; // number of frames in this trace
|
||||
ASGCT_CallFrame *frames; // frames
|
||||
} ASGCT_CallTrace;
|
||||
|
||||
// These name match the names reported by the forte quality kit
|
||||
enum {
|
||||
ticks_no_Java_frame = 0,
|
||||
|
|
@ -50,6 +63,8 @@ enum {
|
|||
ticks_safepoint = -10
|
||||
};
|
||||
|
||||
#if INCLUDE_JVMTI
|
||||
|
||||
//-------------------------------------------------------
|
||||
|
||||
// Native interfaces for use by Forte tools.
|
||||
|
|
@ -360,20 +375,6 @@ static bool find_initial_Java_frame(JavaThread* thread,
|
|||
|
||||
}
|
||||
|
||||
|
||||
// call frame copied from old .h file and renamed
|
||||
typedef struct {
|
||||
jint lineno; // line number in the source file
|
||||
jmethodID method_id; // method executed in this frame
|
||||
} ASGCT_CallFrame;
|
||||
|
||||
// call trace copied from old .h file and renamed
|
||||
typedef struct {
|
||||
JNIEnv *env_id; // Env where trace was recorded
|
||||
jint num_frames; // number of frames in this trace
|
||||
ASGCT_CallFrame *frames; // frames
|
||||
} ASGCT_CallTrace;
|
||||
|
||||
static void forte_fill_call_trace_given_top(JavaThread* thd,
|
||||
ASGCT_CallTrace* trace,
|
||||
int depth,
|
||||
|
|
@ -634,3 +635,12 @@ void Forte::register_stub(const char* name, address start, address end) {
|
|||
pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
|
||||
#endif // !_WINDOWS && !IA64
|
||||
}
|
||||
|
||||
#else // INCLUDE_JVMTI
|
||||
extern "C" {
|
||||
JNIEXPORT
|
||||
void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
|
||||
trace->num_frames = ticks_no_class_load; // -1
|
||||
}
|
||||
}
|
||||
#endif // INCLUDE_JVMTI
|
||||
|
|
|
|||
|
|
@ -1072,11 +1072,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
|
|||
return NULL;
|
||||
}
|
||||
|
||||
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
|
||||
objArrayOop signers = NULL;
|
||||
if (k->oop_is_instance()) {
|
||||
signers = InstanceKlass::cast(k)->signers();
|
||||
}
|
||||
objArrayOop signers = java_lang_Class::signers(JNIHandles::resolve_non_null(cls));
|
||||
|
||||
// If there are no signers set in the class, or if the class
|
||||
// is an array, return NULL.
|
||||
|
|
@ -1102,7 +1098,7 @@ JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signer
|
|||
// be called with an array. Only the bootstrap loader creates arrays.
|
||||
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
|
||||
if (k->oop_is_instance()) {
|
||||
InstanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers)));
|
||||
java_lang_Class::set_signers(k->java_mirror(), objArrayOop(JNIHandles::resolve(signers)));
|
||||
}
|
||||
}
|
||||
JVM_END
|
||||
|
|
@ -1119,8 +1115,8 @@ JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls))
|
|||
return NULL;
|
||||
}
|
||||
|
||||
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
|
||||
return (jobject) JNIHandles::make_local(env, k->protection_domain());
|
||||
oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls));
|
||||
return (jobject) JNIHandles::make_local(env, pd);
|
||||
JVM_END
|
||||
|
||||
|
||||
|
|
@ -1139,7 +1135,7 @@ JVM_ENTRY(void, JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protect
|
|||
if (k->oop_is_instance()) {
|
||||
oop pd = JNIHandles::resolve(protection_domain);
|
||||
assert(pd == NULL || pd->is_oop(), "just checking");
|
||||
InstanceKlass::cast(k)->set_protection_domain(pd);
|
||||
java_lang_Class::set_protection_domain(k->java_mirror(), pd);
|
||||
}
|
||||
}
|
||||
JVM_END
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2008, 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
|
||||
|
|
@ -232,7 +232,8 @@ oop MethodHandles::init_method_MemberName(Handle mname, Method* m, bool do_dispa
|
|||
// This is done eagerly, since it is readily available without
|
||||
// constructing any new objects.
|
||||
// TO DO: maybe intern mname_oop
|
||||
m->method_holder()->add_member_name(mname);
|
||||
m->method_holder()->add_member_name(m->method_idnum(), mname);
|
||||
|
||||
return mname();
|
||||
}
|
||||
|
||||
|
|
@ -301,7 +302,6 @@ oop MethodHandles::init_field_MemberName(Handle mname, KlassHandle field_holder,
|
|||
// Although the fieldDescriptor::_index would also identify the field,
|
||||
// we do not use it, because it is harder to decode.
|
||||
// TO DO: maybe intern mname_oop
|
||||
InstanceKlass::cast(field_holder())->add_member_name(mname);
|
||||
return mname();
|
||||
}
|
||||
|
||||
|
|
@ -943,7 +943,8 @@ int MethodHandles::find_MemberNames(KlassHandle k,
|
|||
// MemberNameTable
|
||||
//
|
||||
|
||||
MemberNameTable::MemberNameTable() : GrowableArray<jweak>(10, true) {
|
||||
MemberNameTable::MemberNameTable(int methods_cnt)
|
||||
: GrowableArray<jweak>(methods_cnt, true) {
|
||||
assert_locked_or_safepoint(MemberNameTable_lock);
|
||||
}
|
||||
|
||||
|
|
@ -957,29 +958,18 @@ MemberNameTable::~MemberNameTable() {
|
|||
}
|
||||
}
|
||||
|
||||
// Return entry index if found, return -1 otherwise.
|
||||
int MemberNameTable::find_member_name(oop mem_name) {
|
||||
void MemberNameTable::add_member_name(int index, jweak mem_name_wref) {
|
||||
assert_locked_or_safepoint(MemberNameTable_lock);
|
||||
int len = this->length();
|
||||
|
||||
for (int idx = 0; idx < len; idx++) {
|
||||
jweak ref = this->at(idx);
|
||||
oop entry = JNIHandles::resolve(ref);
|
||||
if (entry == mem_name) {
|
||||
return idx;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
this->at_put_grow(index, mem_name_wref);
|
||||
}
|
||||
|
||||
void MemberNameTable::add_member_name(jweak mem_name_wref) {
|
||||
// Return a member name oop or NULL.
|
||||
oop MemberNameTable::get_member_name(int index) {
|
||||
assert_locked_or_safepoint(MemberNameTable_lock);
|
||||
oop mem_name = JNIHandles::resolve(mem_name_wref);
|
||||
|
||||
// Each member name may appear just once: add only if not found
|
||||
if (find_member_name(mem_name) == -1) {
|
||||
this->append(mem_name_wref);
|
||||
}
|
||||
jweak ref = this->at(index);
|
||||
oop mem_name = JNIHandles::resolve(ref);
|
||||
return mem_name;
|
||||
}
|
||||
|
||||
#if INCLUDE_JVMTI
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2008, 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
|
||||
|
|
@ -219,7 +219,6 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// MethodHandlesAdapterGenerator
|
||||
//
|
||||
|
|
@ -233,13 +232,13 @@ public:
|
|||
//------------------------------------------------------------------------------
|
||||
// MemberNameTable
|
||||
//
|
||||
|
||||
class MemberNameTable : public GrowableArray<jweak> {
|
||||
public:
|
||||
MemberNameTable();
|
||||
MemberNameTable(int methods_cnt);
|
||||
~MemberNameTable();
|
||||
void add_member_name(jweak mem_name_ref);
|
||||
private:
|
||||
int find_member_name(oop mem_name);
|
||||
void add_member_name(int index, jweak mem_name_ref);
|
||||
oop get_member_name(int index);
|
||||
|
||||
#if INCLUDE_JVMTI
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@
|
|||
#include "runtime/os.hpp"
|
||||
#include "utilities/debug.hpp"
|
||||
#include "utilities/macros.hpp"
|
||||
#include "utilities/exceptions.hpp"
|
||||
|
||||
#if INCLUDE_ALL_GCS
|
||||
#include "gc_implementation/g1/concurrentMark.hpp"
|
||||
|
|
@ -330,8 +331,18 @@ WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
|
|||
WB_END
|
||||
|
||||
|
||||
WB_ENTRY(jlong, WB_ReserveMemory(JNIEnv* env, jobject o, jlong size))
|
||||
return (jlong)os::reserve_memory(size, NULL, 0);
|
||||
WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o))
|
||||
// static+volatile in order to force the read to happen
|
||||
// (not be eliminated by the compiler)
|
||||
static char c;
|
||||
static volatile char* p;
|
||||
|
||||
p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
|
||||
if (p == NULL) {
|
||||
THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
|
||||
}
|
||||
|
||||
c = *p;
|
||||
WB_END
|
||||
|
||||
//Some convenience methods to deal with objects from java
|
||||
|
|
@ -437,7 +448,7 @@ static JNINativeMethod methods[] = {
|
|||
{CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
|
||||
{CC"fullGC", CC"()V", (void*)&WB_FullGC },
|
||||
|
||||
{CC"reserveMemory", CC"(J)J", (void*)&WB_ReserveMemory },
|
||||
{CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
|
||||
};
|
||||
|
||||
#undef CC
|
||||
|
|
|
|||
|
|
@ -292,10 +292,8 @@ typedef BinaryTreeDictionary<Metablock, FreeList> MetablockTreeDictionary;
|
|||
nonstatic_field(InstanceKlass, _transitive_interfaces, Array<Klass*>*) \
|
||||
nonstatic_field(InstanceKlass, _fields, Array<u2>*) \
|
||||
nonstatic_field(InstanceKlass, _java_fields_count, u2) \
|
||||
nonstatic_field(InstanceKlass, _constants, ConstantPool*) \
|
||||
nonstatic_field(InstanceKlass, _constants, ConstantPool*) \
|
||||
nonstatic_field(InstanceKlass, _class_loader_data, ClassLoaderData*) \
|
||||
nonstatic_field(InstanceKlass, _protection_domain, oop) \
|
||||
nonstatic_field(InstanceKlass, _signers, objArrayOop) \
|
||||
nonstatic_field(InstanceKlass, _source_file_name, Symbol*) \
|
||||
nonstatic_field(InstanceKlass, _source_debug_extension, char*) \
|
||||
nonstatic_field(InstanceKlass, _inner_classes, Array<jushort>*) \
|
||||
|
|
|
|||
|
|
@ -34,6 +34,7 @@
|
|||
#include "services/memReporter.hpp"
|
||||
#include "services/memTracker.hpp"
|
||||
#include "utilities/decoder.hpp"
|
||||
#include "utilities/defaultStream.hpp"
|
||||
#include "utilities/globalDefinitions.hpp"
|
||||
|
||||
bool NMT_track_callsite = false;
|
||||
|
|
@ -77,7 +78,15 @@ void MemTracker::init_tracking_options(const char* option_line) {
|
|||
if (strcmp(option_line, "=summary") == 0) {
|
||||
_tracking_level = NMT_summary;
|
||||
} else if (strcmp(option_line, "=detail") == 0) {
|
||||
_tracking_level = NMT_detail;
|
||||
// detail relies on a stack-walking ability that may not
|
||||
// be available depending on platform and/or compiler flags
|
||||
if (PLATFORM_NMT_DETAIL_SUPPORTED) {
|
||||
_tracking_level = NMT_detail;
|
||||
} else {
|
||||
jio_fprintf(defaultStream::error_stream(),
|
||||
"NMT detail is not supported on this platform. Using NMT summary instead.");
|
||||
_tracking_level = NMT_summary;
|
||||
}
|
||||
} else if (strcmp(option_line, "=off") != 0) {
|
||||
vm_exit_during_initialization("Syntax error, expecting -XX:NativeMemoryTracking=[off|summary|detail]", NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -380,6 +380,14 @@ const uint64_t KlassEncodingMetaspaceMax = (uint64_t(max_juint) + 1) << LogKlass
|
|||
# include "globalDefinitions_ppc.hpp"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* If a platform does not support NMT_detail
|
||||
* the platform specific globalDefinitions (above)
|
||||
* can set PLATFORM_NMT_DETAIL_SUPPORTED to false
|
||||
*/
|
||||
#ifndef PLATFORM_NMT_DETAIL_SUPPORTED
|
||||
#define PLATFORM_NMT_DETAIL_SUPPORTED true
|
||||
#endif
|
||||
|
||||
// The byte alignment to be used by Arena::Amalloc. See bugid 4169348.
|
||||
// Note: this value must be a power of 2
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue