archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 06:45:07 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8155672: Remove instanceKlassHandles and KlassHandles

Browse source 
Use unhandled pointers for Klass and InstanceKlass, remove handles with no implementation.

Reviewed-by: dholmes, lfoltan, vlivanov, sspitsyn
This commit is contained in:
Coleen Phillimore 2017-03-15 10:25:37 -04:00
parent 7bca463789
commit 4b9562288f
152 changed files with 1892 additions and 2112 deletions
Download patch file Download diff file Expand all files Collapse all files

41
hotspot/src/share/vm/classfile/loaderConstraints.cpp
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2017, 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
@ -36,15 +36,15 @@ void LoaderConstraintEntry::set_loader(int i, oop p) {
}
LoaderConstraintTable::LoaderConstraintTable(int nof_buckets)
: Hashtable<Klass*, mtClass>(nof_buckets, sizeof(LoaderConstraintEntry)) {};
: Hashtable<InstanceKlass*, mtClass>(nof_buckets, sizeof(LoaderConstraintEntry)) {};
LoaderConstraintEntry* LoaderConstraintTable::new_entry(
unsigned int hash, Symbol* name,
Klass* klass, int num_loaders,
InstanceKlass* klass, int num_loaders,
int max_loaders) {
LoaderConstraintEntry* entry;
entry = (LoaderConstraintEntry*)Hashtable<Klass*, mtClass>::new_entry(hash, klass);
entry = (LoaderConstraintEntry*)Hashtable<InstanceKlass*, mtClass>::new_entry(hash, klass);
entry->set_name(name);
entry->set_num_loaders(num_loaders);
entry->set_max_loaders(max_loaders);
@ -54,7 +54,7 @@ LoaderConstraintEntry* LoaderConstraintTable::new_entry(
void LoaderConstraintTable::free_entry(LoaderConstraintEntry *entry) {
// decrement name refcount before freeing
entry->name()->decrement_refcount();
Hashtable<Klass*, mtClass>::free_entry(entry);
Hashtable<InstanceKlass*, mtClass>::free_entry(entry);
}
// Enhanced Class Redefinition support
@ -106,7 +106,7 @@ void LoaderConstraintTable::purge_loader_constraints() {
LoaderConstraintEntry** p = bucket_addr(index);
while(*p) {
LoaderConstraintEntry* probe = *p;
Klass* klass = probe->klass();
InstanceKlass* klass = probe->klass();
// Remove klass that is no longer alive
if (klass != NULL &&
klass->class_loader_data()->is_unloading()) {
@ -186,14 +186,14 @@ void LoaderConstraintTable::purge_loader_constraints() {
}
bool LoaderConstraintTable::add_entry(Symbol* class_name,
Klass* klass1, Handle class_loader1,
Klass* klass2, Handle class_loader2) {
InstanceKlass* klass1, Handle class_loader1,
InstanceKlass* klass2, Handle class_loader2) {
int failure_code = 0; // encode different reasons for failing
if (klass1 != NULL && klass2 != NULL && klass1 != klass2) {
failure_code = 1;
} else {
Klass* klass = klass1 != NULL ? klass1 : klass2;
InstanceKlass* klass = klass1 != NULL ? klass1 : klass2;
LoaderConstraintEntry** pp1 = find_loader_constraint(class_name,
class_loader1);
@ -295,11 +295,11 @@ bool LoaderConstraintTable::add_entry(Symbol* class_name,
// return true if the constraint was updated, false if the constraint is
// violated
bool LoaderConstraintTable::check_or_update(instanceKlassHandle k,
Handle loader,
Symbol* name) {
bool LoaderConstraintTable::check_or_update(InstanceKlass* k,
Handle loader,
Symbol* name) {
LoaderConstraintEntry* p = *(find_loader_constraint(name, loader));
if (p && p->klass() != NULL && p->klass() != k()) {
if (p && p->klass() != NULL && p->klass() != k) {
if (log_is_enabled(Info, class, loader, constraints)) {
ResourceMark rm;
outputStream* out = Log(class, loader, constraints)::info_stream();
@ -311,7 +311,7 @@ bool LoaderConstraintTable::check_or_update(instanceKlassHandle k,
return false;
} else {
if (p && p->klass() == NULL) {
p->set_klass(k());
p->set_klass(k);
if (log_is_enabled(Info, class, loader, constraints)) {
ResourceMark rm;
outputStream* out = Log(class, loader, constraints)::info_stream();
@ -325,11 +325,12 @@ bool LoaderConstraintTable::check_or_update(instanceKlassHandle k,
}
}
Klass* LoaderConstraintTable::find_constrained_klass(Symbol* name,
InstanceKlass* LoaderConstraintTable::find_constrained_klass(Symbol* name,
Handle loader) {
LoaderConstraintEntry *p = *(find_loader_constraint(name, loader));
if (p != NULL && p->klass() != NULL) {
if (p->klass()->is_instance_klass() && !InstanceKlass::cast(p->klass())->is_loaded()) {
assert(p->klass()->is_instance_klass(), "sanity");
if (p->klass()->is_loaded()) {
// Only return fully loaded classes. Classes found through the
// constraints might still be in the process of loading.
return NULL;
@ -357,7 +358,7 @@ void LoaderConstraintTable::ensure_loader_constraint_capacity(
void LoaderConstraintTable::extend_loader_constraint(LoaderConstraintEntry* p,
Handle loader,
Klass* klass) {
InstanceKlass* klass) {
ensure_loader_constraint_capacity(p, 1);
int num = p->num_loaders();
p->set_loader(num, loader());
@ -383,7 +384,7 @@ void LoaderConstraintTable::extend_loader_constraint(LoaderConstraintEntry* p,
void LoaderConstraintTable::merge_loader_constraints(
LoaderConstraintEntry** pp1,
LoaderConstraintEntry** pp2,
Klass* klass) {
InstanceKlass* klass) {
// make sure *pp1 has higher capacity
if ((*pp1)->max_loaders() < (*pp2)->max_loaders()) {
LoaderConstraintEntry** tmp = pp2;
@ -447,13 +448,13 @@ void LoaderConstraintTable::verify(Dictionary* dictionary,
probe != NULL;
probe = probe->next()) {
if (probe->klass() != NULL) {
InstanceKlass* ik = InstanceKlass::cast(probe->klass());
InstanceKlass* ik = probe->klass();
guarantee(ik->name() == probe->name(), "name should match");
Symbol* name = ik->name();
ClassLoaderData* loader_data = ik->class_loader_data();
unsigned int d_hash = dictionary->compute_hash(name, loader_data);
int d_index = dictionary->hash_to_index(d_hash);
Klass* k = dictionary->find_class(d_index, d_hash, name, loader_data);
InstanceKlass* k = dictionary->find_class(d_index, d_hash, name, loader_data);
if (k != NULL) {
// We found the class in the system dictionary, so we should
// make sure that the Klass* matches what we already have.