< prev index next >
src/hotspot/share/classfile/systemDictionaryShared.cpp
Print this page
@@ -95,28 +95,28 @@
}
};
InstanceKlass* _klass;
bool _failed_verification;
+ bool _is_archived_lambda_proxy;
int _id;
int _clsfile_size;
int _clsfile_crc32;
GrowableArray<DTVerifierConstraint>* _verifier_constraints;
GrowableArray<char>* _verifier_constraint_flags;
- bool _is_archived_lambda_proxy;
GrowableArray<DTLoaderConstraint>* _loader_constraints;
DumpTimeSharedClassInfo() {
_klass = NULL;
_failed_verification = false;
+ _is_archived_lambda_proxy = false;
_id = -1;
_clsfile_size = -1;
_clsfile_crc32 = -1;
_excluded = false;
_verifier_constraints = NULL;
_verifier_constraint_flags = NULL;
- _is_archived_lambda_proxy = false;
_loader_constraints = NULL;
}
void add_verification_constraint(InstanceKlass* k, Symbol* name,
Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object);
@@ -319,40 +319,40 @@
};
class DumpTimeLambdaProxyClassInfo {
public:
- GrowableArray<InstanceKlass*>* _proxy_klass;
- DumpTimeLambdaProxyClassInfo() : _proxy_klass(NULL) {}
+ GrowableArray<InstanceKlass*>* _proxy_klasses;
+ DumpTimeLambdaProxyClassInfo() : _proxy_klasses(NULL) {}
void add_proxy_klass(InstanceKlass* proxy_klass) {
- if (_proxy_klass == NULL) {
- _proxy_klass = new (ResourceObj::C_HEAP, mtInternal)GrowableArray<InstanceKlass*>(5, true);
+ if (_proxy_klasses == NULL) {
+ _proxy_klasses = new (ResourceObj::C_HEAP, mtInternal)GrowableArray<InstanceKlass*>(5, true);
}
- assert(_proxy_klass != NULL, "sanity");
- _proxy_klass->append(proxy_klass);
+ assert(_proxy_klasses != NULL, "sanity");
+ _proxy_klasses->append(proxy_klass);
}
};
class RunTimeLambdaProxyClassInfo {
LambdaProxyClassKey _key;
- InstanceKlass* _proxy_klass;
+ InstanceKlass* _proxy_klass_head;
public:
RunTimeLambdaProxyClassInfo(LambdaProxyClassKey key, InstanceKlass* proxy_klass) :
- _key(key), _proxy_klass(proxy_klass) {}
+ _key(key), _proxy_klass_head(proxy_klass) {}
- InstanceKlass* proxy_klass() const { return _proxy_klass; }
+ InstanceKlass* proxy_klass_head() const { return _proxy_klass_head; }
// Used by LambdaProxyClassDictionary to implement OffsetCompactHashtable::EQUALS
static inline bool EQUALS(
const RunTimeLambdaProxyClassInfo* value, LambdaProxyClassKey* key, int len_unused) {
return (value->_key.equals(*key));
}
void init(LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) {
_key = key;
_key.original_to_target();
- _proxy_klass = DynamicArchive::original_to_target(info._proxy_klass->at(0));
- ArchivePtrMarker::mark_pointer(&_proxy_klass);
+ _proxy_klass_head = DynamicArchive::original_to_target(info._proxy_klasses->at(0));
+ ArchivePtrMarker::mark_pointer(&_proxy_klass_head);
}
unsigned int hash() const {
return _key.hash();
}
@@ -378,10 +378,11 @@
DumpTimeLambdaProxyClassDictionary* _dumptime_lambda_proxy_class_dictionary = NULL;
static void add_to_dump_time_lambda_proxy_class_dictionary(LambdaProxyClassKey key,
InstanceKlass* proxy_klass) {
+ assert(DumpTimeTable_lock->owned_by_self(), "sanity");
if (_dumptime_lambda_proxy_class_dictionary == NULL) {
_dumptime_lambda_proxy_class_dictionary =
new (ResourceObj::C_HEAP, mtClass)DumpTimeLambdaProxyClassDictionary();
}
DumpTimeLambdaProxyClassInfo* lambda_info = _dumptime_lambda_proxy_class_dictionary->get(key);
@@ -579,11 +580,10 @@
if (_klass->is_hidden()) {
Thread* THREAD = Thread::current();
InstanceKlass* n_h = _klass->nest_host(THREAD);
n_h = DynamicArchive::original_to_target(n_h);
set_nest_host(n_h);
- ArchivePtrMarker::mark_pointer(&n_h);
}
_klass = DynamicArchive::original_to_target(info._klass);
}
ArchivePtrMarker::mark_pointer(&_klass);
}
@@ -1336,11 +1336,11 @@
return false;
}
bool SystemDictionaryShared::is_registered_lambda_proxy_class(InstanceKlass* ik) {
DumpTimeSharedClassInfo* info = _dumptime_table->get(ik);
- return (info != NULL) ? info->_is_archived_lambda_proxy && !ik->is_non_strong_hidden() : false;
+ return (info != NULL) ? info->_is_archived_lambda_proxy : false;
}
bool SystemDictionaryShared::is_in_shared_lambda_proxy_table(InstanceKlass* ik) {
assert(!DumpSharedSpaces && UseSharedSpaces, "called at run time with CDS enabled only");
RunTimeSharedClassInfo* record = RunTimeSharedClassInfo::get_for(ik);
@@ -1352,11 +1352,10 @@
}
bool SystemDictionaryShared::is_hidden_lambda_proxy(InstanceKlass* ik) {
assert(ik->is_shared(), "applicable to only a shared class");
if (ik->is_hidden()) {
- assert(is_in_shared_lambda_proxy_table(ik), "we don't archive other hidden classes");
return true;
} else {
return false;
}
}
@@ -1602,11 +1601,11 @@
MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
lambda_ik->assign_class_loader_type();
DumpTimeSharedClassInfo* info = _dumptime_table->get(lambda_ik);
- if (info != NULL) {
+ if (info != NULL && !lambda_ik->is_non_strong_hidden()) {
// Set _is_archived_lambda_proxy in DumpTimeSharedClassInfo so that the lambda_ik
// won't be excluded during dumping of shared archive. See ExcludeDumpTimeSharedClasses.
info->_is_archived_lambda_proxy = true;
}
@@ -1629,11 +1628,11 @@
LambdaProxyClassKey key(caller_ik, invoked_name, invoked_type,
method_type, member_method, instantiated_method_type);
const RunTimeLambdaProxyClassInfo* info = _lambda_proxy_class_dictionary.lookup(&key, key.hash(), 0);
InstanceKlass* proxy_klass = NULL;
if (info != NULL) {
- InstanceKlass* curr_klass = info->proxy_klass();
+ InstanceKlass* curr_klass = info->proxy_klass_head();
InstanceKlass* prev_klass = curr_klass;
if (curr_klass->lambda_proxy_is_available()) {
while (curr_klass->next_link() != NULL) {
prev_klass = curr_klass;
curr_klass = InstanceKlass::cast(curr_klass->next_link());
@@ -1959,15 +1958,15 @@
CompactHashtableWriter* _writer;
public:
CopyLambdaProxyClassInfoToArchive(CompactHashtableWriter* writer)
: _writer(writer) {}
bool do_entry(LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) {
- if (SystemDictionaryShared::is_excluded_class(info._proxy_klass->at(0))) {
+ if (SystemDictionaryShared::is_excluded_class(info._proxy_klasses->at(0))) {
return true;
}
ResourceMark rm;
- log_info(cds,dynamic)("Archiving hidden %s", info._proxy_klass->at(0)->external_name());
+ log_info(cds,dynamic)("Archiving hidden %s", info._proxy_klasses->at(0)->external_name());
size_t byte_size = sizeof(RunTimeLambdaProxyClassInfo);
RunTimeLambdaProxyClassInfo* runtime_info =
(RunTimeLambdaProxyClassInfo*)MetaspaceShared::read_only_space_alloc(byte_size);
runtime_info->init(key, info);
unsigned int hash = runtime_info->hash(); // Fields in runtime_info->_key already point to target space.
@@ -1979,28 +1978,28 @@
class AdjustLambdaProxyClassInfo : StackObj {
public:
AdjustLambdaProxyClassInfo() {}
bool do_entry(LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) {
- if (SystemDictionaryShared::is_excluded_class(info._proxy_klass->at(0))) {
+ if (SystemDictionaryShared::is_excluded_class(info._proxy_klasses->at(0))) {
return true;
}
- int len = info._proxy_klass->length();
+ int len = info._proxy_klasses->length();
if (len > 1) {
for (int i = 0; i < len-1; i++) {
- InstanceKlass* ok0 = info._proxy_klass->at(i+0); // this is original klass
- InstanceKlass* ok1 = info._proxy_klass->at(i+1); // this is original klass
+ InstanceKlass* ok0 = info._proxy_klasses->at(i+0); // this is original klass
+ InstanceKlass* ok1 = info._proxy_klasses->at(i+1); // this is original klass
InstanceKlass* bk0 = DynamicArchive::original_to_buffer(ok0);
InstanceKlass* bk1 = DynamicArchive::original_to_buffer(ok1);
assert(bk0->next_link() == 0, "must be called after Klass::remove_unshareable_info()");
assert(bk1->next_link() == 0, "must be called after Klass::remove_unshareable_info()");
bk0->set_next_link(bk1);
bk1->set_lambda_proxy_is_available();
ArchivePtrMarker::mark_pointer(bk0->next_link_addr());
}
}
- DynamicArchive::original_to_buffer(info._proxy_klass->at(0))->set_lambda_proxy_is_available();
+ DynamicArchive::original_to_buffer(info._proxy_klasses->at(0))->set_lambda_proxy_is_available();
return true;
}
};
class CopySharedClassInfoToArchive : StackObj {
@@ -2162,12 +2161,12 @@
public:
SharedLambdaDictionaryPrinter(outputStream* st) : _st(st), _index(0) {}
void do_value(const RunTimeLambdaProxyClassInfo* record) {
ResourceMark rm;
- _st->print_cr("%4d: %s", (_index++), record->proxy_klass()->external_name());
- Klass* k = record->proxy_klass()->next_link();
+ _st->print_cr("%4d: %s", (_index++), record->proxy_klass_head()->external_name());
+ Klass* k = record->proxy_klass_head()->next_link();
while (k != NULL) {
_st->print_cr("%4d: %s", (_index++), k->external_name());
k = k->next_link();
}
}
< prev index next >