--- a/hotspot/src/share/vm/oops/instanceKlass.cpp Tue Mar 25 09:26:18 2014 -0400
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Wed Mar 26 21:47:45 2014 -0400
@@ -432,8 +432,8 @@
if (!InstanceKlass::cast(super)->is_initialized()) return;
// call body to expose the this pointer
- instanceKlassHandle this_oop(thread, this);
- eager_initialize_impl(this_oop);
+ instanceKlassHandle this_k(thread, this);
+ eager_initialize_impl(this_k);
}
}
@@ -470,16 +470,16 @@
assert(!is_not_initialized(), "class must be initialized now");
}
-void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {
+void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_k) {
EXCEPTION_MARK;
- oop init_lock = this_oop->init_lock();
+ oop init_lock = this_k->init_lock();
ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
// abort if someone beat us to the initialization
- if (!this_oop->is_not_initialized()) return; // note: not equivalent to is_initialized()
-
- ClassState old_state = this_oop->init_state();
- link_class_impl(this_oop, true, THREAD);
+ if (!this_k->is_not_initialized()) return; // note: not equivalent to is_initialized()
+
+ ClassState old_state = this_k->init_state();
+ link_class_impl(this_k, true, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
// Abort if linking the class throws an exception.
@@ -487,16 +487,16 @@
// Use a test to avoid redundantly resetting the state if there's
// no change. Set_init_state() asserts that state changes make
// progress, whereas here we might just be spinning in place.
- if( old_state != this_oop->_init_state )
- this_oop->set_init_state (old_state);
+ if( old_state != this_k->_init_state )
+ this_k->set_init_state (old_state);
} else {
// linking successfull, mark class as initialized
- this_oop->set_init_state (fully_initialized);
- this_oop->fence_and_clear_init_lock();
+ this_k->set_init_state (fully_initialized);
+ this_k->fence_and_clear_init_lock();
// trace
if (TraceClassInitialization) {
ResourceMark rm(THREAD);
- tty->print_cr("[Initialized %s without side effects]", this_oop->external_name());
+ tty->print_cr("[Initialized %s without side effects]", this_k->external_name());
}
}
}
@@ -508,8 +508,8 @@
void InstanceKlass::initialize(TRAPS) {
if (this->should_be_initialized()) {
HandleMark hm(THREAD);
- instanceKlassHandle this_oop(THREAD, this);
- initialize_impl(this_oop, CHECK);
+ instanceKlassHandle this_k(THREAD, this);
+ initialize_impl(this_k, CHECK);
// Note: at this point the class may be initialized
// OR it may be in the state of being initialized
// in case of recursive initialization!
@@ -520,11 +520,11 @@
bool InstanceKlass::verify_code(
- instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
+ instanceKlassHandle this_k, bool throw_verifyerror, TRAPS) {
// 1) Verify the bytecodes
Verifier::Mode mode =
throw_verifyerror ? Verifier::ThrowException : Verifier::NoException;
- return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false);
+ return Verifier::verify(this_k, mode, this_k->should_verify_class(), CHECK_false);
}
@@ -540,8 +540,8 @@
assert(is_loaded(), "must be loaded");
if (!is_linked()) {
HandleMark hm(THREAD);
- instanceKlassHandle this_oop(THREAD, this);
- link_class_impl(this_oop, true, CHECK);
+ instanceKlassHandle this_k(THREAD, this);
+ link_class_impl(this_k, true, CHECK);
}
}
@@ -551,22 +551,22 @@
assert(is_loaded(), "must be loaded");
if (!is_linked()) {
HandleMark hm(THREAD);
- instanceKlassHandle this_oop(THREAD, this);
- link_class_impl(this_oop, false, CHECK_false);
+ instanceKlassHandle this_k(THREAD, this);
+ link_class_impl(this_k, false, CHECK_false);
}
return is_linked();
}
bool InstanceKlass::link_class_impl(
- instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
+ instanceKlassHandle this_k, bool throw_verifyerror, TRAPS) {
// check for error state
- if (this_oop->is_in_error_state()) {
+ if (this_k->is_in_error_state()) {
ResourceMark rm(THREAD);
THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(),
- this_oop->external_name(), false);
+ this_k->external_name(), false);
}
// return if already verified
- if (this_oop->is_linked()) {
+ if (this_k->is_linked()) {
return true;
}
@@ -576,7 +576,7 @@
JavaThread* jt = (JavaThread*)THREAD;
// link super class before linking this class
- instanceKlassHandle super(THREAD, this_oop->super());
+ instanceKlassHandle super(THREAD, this_k->super());
if (super.not_null()) {
if (super->is_interface()) { // check if super class is an interface
ResourceMark rm(THREAD);
@@ -584,7 +584,7 @@
THREAD_AND_LOCATION,
vmSymbols::java_lang_IncompatibleClassChangeError(),
"class %s has interface %s as super class",
- this_oop->external_name(),
+ this_k->external_name(),
super->external_name()
);
return false;
@@ -594,7 +594,7 @@
}
// link all interfaces implemented by this class before linking this class
- Array<Klass*>* interfaces = this_oop->local_interfaces();
+ Array<Klass*>* interfaces = this_k->local_interfaces();
int num_interfaces = interfaces->length();
for (int index = 0; index < num_interfaces; index++) {
HandleMark hm(THREAD);
@@ -603,7 +603,7 @@
}
// in case the class is linked in the process of linking its superclasses
- if (this_oop->is_linked()) {
+ if (this_k->is_linked()) {
return true;
}
@@ -618,14 +618,14 @@
// verification & rewriting
{
- oop init_lock = this_oop->init_lock();
+ oop init_lock = this_k->init_lock();
ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
// rewritten will have been set if loader constraint error found
// on an earlier link attempt
// don't verify or rewrite if already rewritten
- if (!this_oop->is_linked()) {
- if (!this_oop->is_rewritten()) {
+ if (!this_k->is_linked()) {
+ if (!this_k->is_rewritten()) {
{
// Timer includes any side effects of class verification (resolution,
// etc), but not recursive entry into verify_code().
@@ -635,7 +635,7 @@
jt->get_thread_stat()->perf_recursion_counts_addr(),
jt->get_thread_stat()->perf_timers_addr(),
PerfClassTraceTime::CLASS_VERIFY);
- bool verify_ok = verify_code(this_oop, throw_verifyerror, THREAD);
+ bool verify_ok = verify_code(this_k, throw_verifyerror, THREAD);
if (!verify_ok) {
return false;
}
@@ -644,39 +644,39 @@
// Just in case a side-effect of verify linked this class already
// (which can sometimes happen since the verifier loads classes
// using custom class loaders, which are free to initialize things)
- if (this_oop->is_linked()) {
+ if (this_k->is_linked()) {
return true;
}
// also sets rewritten
- this_oop->rewrite_class(CHECK_false);
+ this_k->rewrite_class(CHECK_false);
}
// relocate jsrs and link methods after they are all rewritten
- this_oop->link_methods(CHECK_false);
+ this_k->link_methods(CHECK_false);
// Initialize the vtable and interface table after
// methods have been rewritten since rewrite may
// fabricate new Method*s.
// also does loader constraint checking
- if (!this_oop()->is_shared()) {
+ if (!this_k()->is_shared()) {
ResourceMark rm(THREAD);
- this_oop->vtable()->initialize_vtable(true, CHECK_false);
- this_oop->itable()->initialize_itable(true, CHECK_false);
+ this_k->vtable()->initialize_vtable(true, CHECK_false);
+ this_k->itable()->initialize_itable(true, CHECK_false);
}
#ifdef ASSERT
else {
ResourceMark rm(THREAD);
- this_oop->vtable()->verify(tty, true);
+ this_k->vtable()->verify(tty, true);
// In case itable verification is ever added.
- // this_oop->itable()->verify(tty, true);
+ // this_k->itable()->verify(tty, true);
}
#endif
- this_oop->set_init_state(linked);
+ this_k->set_init_state(linked);
if (JvmtiExport::should_post_class_prepare()) {
Thread *thread = THREAD;
assert(thread->is_Java_thread(), "thread->is_Java_thread()");
- JvmtiExport::post_class_prepare((JavaThread *) thread, this_oop());
+ JvmtiExport::post_class_prepare((JavaThread *) thread, this_k());
}
}
}
@@ -689,13 +689,13 @@
// verification but before the first method of the class is executed.
void InstanceKlass::rewrite_class(TRAPS) {
assert(is_loaded(), "must be loaded");
- instanceKlassHandle this_oop(THREAD, this);
- if (this_oop->is_rewritten()) {
- assert(this_oop()->is_shared(), "rewriting an unshared class?");
+ instanceKlassHandle this_k(THREAD, this);
+ if (this_k->is_rewritten()) {
+ assert(this_k()->is_shared(), "rewriting an unshared class?");
return;
}
- Rewriter::rewrite(this_oop, CHECK);
- this_oop->set_rewritten();
+ Rewriter::rewrite(this_k, CHECK);
+ this_k->set_rewritten();
}
// Now relocate and link method entry points after class is rewritten.
@@ -729,19 +729,19 @@
}
-void InstanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) {
+void InstanceKlass::initialize_impl(instanceKlassHandle this_k, TRAPS) {
// Make sure klass is linked (verified) before initialization
// A class could already be verified, since it has been reflected upon.
- this_oop->link_class(CHECK);
-
- DTRACE_CLASSINIT_PROBE(required, InstanceKlass::cast(this_oop()), -1);
+ this_k->link_class(CHECK);
+
+ DTRACE_CLASSINIT_PROBE(required, InstanceKlass::cast(this_k()), -1);
bool wait = false;
// refer to the JVM book page 47 for description of steps
// Step 1
{
- oop init_lock = this_oop->init_lock();
+ oop init_lock = this_k->init_lock();
ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
Thread *self = THREAD; // it's passed the current thread
@@ -750,29 +750,29 @@
// If we were to use wait() instead of waitInterruptibly() then
// we might end up throwing IE from link/symbol resolution sites
// that aren't expected to throw. This would wreak havoc. See 6320309.
- while(this_oop->is_being_initialized() && !this_oop->is_reentrant_initialization(self)) {
+ while(this_k->is_being_initialized() && !this_k->is_reentrant_initialization(self)) {
wait = true;
ol.waitUninterruptibly(CHECK);
}
// Step 3
- if (this_oop->is_being_initialized() && this_oop->is_reentrant_initialization(self)) {
- DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_oop()), -1,wait);
+ if (this_k->is_being_initialized() && this_k->is_reentrant_initialization(self)) {
+ DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_k()), -1,wait);
return;
}
// Step 4
- if (this_oop->is_initialized()) {
- DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_oop()), -1,wait);
+ if (this_k->is_initialized()) {
+ DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_k()), -1,wait);
return;
}
// Step 5
- if (this_oop->is_in_error_state()) {
- DTRACE_CLASSINIT_PROBE_WAIT(erroneous, InstanceKlass::cast(this_oop()), -1,wait);
+ if (this_k->is_in_error_state()) {
+ DTRACE_CLASSINIT_PROBE_WAIT(erroneous, InstanceKlass::cast(this_k()), -1,wait);
ResourceMark rm(THREAD);
const char* desc = "Could not initialize class ";
- const char* className = this_oop->external_name();
+ const char* className = this_k->external_name();
size_t msglen = strlen(desc) + strlen(className) + 1;
char* message = NEW_RESOURCE_ARRAY(char, msglen);
if (NULL == message) {
@@ -785,13 +785,13 @@
}
// Step 6
- this_oop->set_init_state(being_initialized);
- this_oop->set_init_thread(self);
+ this_k->set_init_state(being_initialized);
+ this_k->set_init_thread(self);
}
// Step 7
- Klass* super_klass = this_oop->super();
- if (super_klass != NULL && !this_oop->is_interface() && super_klass->should_be_initialized()) {
+ Klass* super_klass = this_k->super();
+ if (super_klass != NULL && !this_k->is_interface() && super_klass->should_be_initialized()) {
super_klass->initialize(THREAD);
if (HAS_PENDING_EXCEPTION) {
@@ -799,18 +799,18 @@
CLEAR_PENDING_EXCEPTION;
{
EXCEPTION_MARK;
- this_oop->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads
+ this_k->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads
CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, superclass initialization error is thrown below
}
- DTRACE_CLASSINIT_PROBE_WAIT(super__failed, InstanceKlass::cast(this_oop()), -1,wait);
+ DTRACE_CLASSINIT_PROBE_WAIT(super__failed, InstanceKlass::cast(this_k()), -1,wait);
THROW_OOP(e());
}
}
- if (this_oop->has_default_methods()) {
+ if (this_k->has_default_methods()) {
// Step 7.5: initialize any interfaces which have default methods
- for (int i = 0; i < this_oop->local_interfaces()->length(); ++i) {
- Klass* iface = this_oop->local_interfaces()->at(i);
+ for (int i = 0; i < this_k->local_interfaces()->length(); ++i) {
+ Klass* iface = this_k->local_interfaces()->at(i);
InstanceKlass* ik = InstanceKlass::cast(iface);
if (ik->has_default_methods() && ik->should_be_initialized()) {
ik->initialize(THREAD);
@@ -821,7 +821,7 @@
{
EXCEPTION_MARK;
// Locks object, set state, and notify all waiting threads
- this_oop->set_initialization_state_and_notify(
+ this_k->set_initialization_state_and_notify(
initialization_error, THREAD);
// ignore any exception thrown, superclass initialization error is
@@ -829,7 +829,7 @@
CLEAR_PENDING_EXCEPTION;
}
DTRACE_CLASSINIT_PROBE_WAIT(
- super__failed, InstanceKlass::cast(this_oop()), -1, wait);
+ super__failed, InstanceKlass::cast(this_k()), -1, wait);
THROW_OOP(e());
}
}
@@ -840,7 +840,7 @@
{
assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl");
JavaThread* jt = (JavaThread*)THREAD;
- DTRACE_CLASSINIT_PROBE_WAIT(clinit, InstanceKlass::cast(this_oop()), -1,wait);
+ DTRACE_CLASSINIT_PROBE_WAIT(clinit, InstanceKlass::cast(this_k()), -1,wait);
// Timer includes any side effects of class initialization (resolution,
// etc), but not recursive entry into call_class_initializer().
PerfClassTraceTime timer(ClassLoader::perf_class_init_time(),
@@ -849,14 +849,14 @@
jt->get_thread_stat()->perf_recursion_counts_addr(),
jt->get_thread_stat()->perf_timers_addr(),
PerfClassTraceTime::CLASS_CLINIT);
- this_oop->call_class_initializer(THREAD);
+ this_k->call_class_initializer(THREAD);
}
// Step 9
if (!HAS_PENDING_EXCEPTION) {
- this_oop->set_initialization_state_and_notify(fully_initialized, CHECK);
+ this_k->set_initialization_state_and_notify(fully_initialized, CHECK);
{ ResourceMark rm(THREAD);
- debug_only(this_oop->vtable()->verify(tty, true);)
+ debug_only(this_k->vtable()->verify(tty, true);)
}
}
else {
@@ -868,13 +868,13 @@
JvmtiExport::clear_detected_exception((JavaThread*)THREAD);
{
EXCEPTION_MARK;
- this_oop->set_initialization_state_and_notify(initialization_error, THREAD);
+ this_k->set_initialization_state_and_notify(initialization_error, THREAD);
CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below
// JVMTI has already reported the pending exception
// JVMTI internal flag reset is needed in order to report ExceptionInInitializerError
JvmtiExport::clear_detected_exception((JavaThread*)THREAD);
}
- DTRACE_CLASSINIT_PROBE_WAIT(error, InstanceKlass::cast(this_oop()), -1,wait);
+ DTRACE_CLASSINIT_PROBE_WAIT(error, InstanceKlass::cast(this_k()), -1,wait);
if (e->is_a(SystemDictionary::Error_klass())) {
THROW_OOP(e());
} else {
@@ -884,7 +884,7 @@
&args);
}
}
- DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_oop()), -1,wait);
+ DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_k()), -1,wait);
}
@@ -894,11 +894,11 @@
set_initialization_state_and_notify_impl(kh, state, CHECK);
}
-void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {
- oop init_lock = this_oop->init_lock();
+void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_k, ClassState state, TRAPS) {
+ oop init_lock = this_k->init_lock();
ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
- this_oop->set_init_state(state);
- this_oop->fence_and_clear_init_lock();
+ this_k->set_init_state(state);
+ this_k->fence_and_clear_init_lock();
ol.notify_all(CHECK);
}
@@ -952,12 +952,11 @@
void InstanceKlass::process_interfaces(Thread *thread) {
// link this class into the implementors list of every interface it implements
- Klass* this_as_klass_oop = this;
for (int i = local_interfaces()->length() - 1; i >= 0; i--) {
assert(local_interfaces()->at(i)->is_klass(), "must be a klass");
InstanceKlass* interf = InstanceKlass::cast(local_interfaces()->at(i));
assert(interf->is_interface(), "expected interface");
- interf->add_implementor(this_as_klass_oop);
+ interf->add_implementor(this);
}
}
@@ -1083,12 +1082,12 @@
}
Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) {
- instanceKlassHandle this_oop(THREAD, this);
- return array_klass_impl(this_oop, or_null, n, THREAD);
+ instanceKlassHandle this_k(THREAD, this);
+ return array_klass_impl(this_k, or_null, n, THREAD);
}
-Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_null, int n, TRAPS) {
- if (this_oop->array_klasses() == NULL) {
+Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_k, bool or_null, int n, TRAPS) {
+ if (this_k->array_klasses() == NULL) {
if (or_null) return NULL;
ResourceMark rm;
@@ -1099,14 +1098,14 @@
MutexLocker ma(MultiArray_lock, THREAD);
// Check if update has already taken place
- if (this_oop->array_klasses() == NULL) {
- Klass* k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
- this_oop->set_array_klasses(k);
+ if (this_k->array_klasses() == NULL) {
+ Klass* k = ObjArrayKlass::allocate_objArray_klass(this_k->class_loader_data(), 1, this_k, CHECK_NULL);
+ this_k->set_array_klasses(k);
}
}
}
// _this will always be set at this point
- ObjArrayKlass* oak = (ObjArrayKlass*)this_oop->array_klasses();
+ ObjArrayKlass* oak = (ObjArrayKlass*)this_k->array_klasses();
if (or_null) {
return oak->array_klass_or_null(n);
}
@@ -1133,20 +1132,20 @@
return NULL;
}
-void InstanceKlass::call_class_initializer_impl(instanceKlassHandle this_oop, TRAPS) {
+void InstanceKlass::call_class_initializer_impl(instanceKlassHandle this_k, TRAPS) {
if (ReplayCompiles &&
(ReplaySuppressInitializers == 1 ||
- ReplaySuppressInitializers >= 2 && this_oop->class_loader() != NULL)) {
+ ReplaySuppressInitializers >= 2 && this_k->class_loader() != NULL)) {
// Hide the existence of the initializer for the purpose of replaying the compile
return;
}
- methodHandle h_method(THREAD, this_oop->class_initializer());
- assert(!this_oop->is_initialized(), "we cannot initialize twice");
+ methodHandle h_method(THREAD, this_k->class_initializer());
+ assert(!this_k->is_initialized(), "we cannot initialize twice");
if (TraceClassInitialization) {
tty->print("%d Initializing ", call_class_initializer_impl_counter++);
- this_oop->name()->print_value();
- tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_oop());
+ this_k->name()->print_value();
+ tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_k());
}
if (h_method() != NULL) {
JavaCallArguments args; // No arguments
@@ -1296,8 +1295,8 @@
}
-void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
- for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) {
+void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_k, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
+ for (JavaFieldStream fs(this_k()); !fs.done(); fs.next()) {
if (fs.access_flags().is_static()) {
fieldDescriptor& fd = fs.field_descriptor();
f(&fd, CHECK);
@@ -1515,14 +1514,14 @@
}
/* jni_id_for_impl for jfieldIds only */
-JNIid* InstanceKlass::jni_id_for_impl(instanceKlassHandle this_oop, int offset) {
+JNIid* InstanceKlass::jni_id_for_impl(instanceKlassHandle this_k, int offset) {
MutexLocker ml(JfieldIdCreation_lock);
// Retry lookup after we got the lock
- JNIid* probe = this_oop->jni_ids() == NULL ? NULL : this_oop->jni_ids()->find(offset);
+ JNIid* probe = this_k->jni_ids() == NULL ? NULL : this_k->jni_ids()->find(offset);
if (probe == NULL) {
// Slow case, allocate new static field identifier
- probe = new JNIid(this_oop(), offset, this_oop->jni_ids());
- this_oop->set_jni_ids(probe);
+ probe = new JNIid(this_k(), offset, this_k->jni_ids());
+ this_k->set_jni_ids(probe);
}
return probe;
}
@@ -3161,8 +3160,8 @@
}
// Verify first subklass
- if (subklass_oop() != NULL) {
- guarantee(subklass_oop()->is_klass(), "should be klass");
+ if (subklass() != NULL) {
+ guarantee(subklass()->is_klass(), "should be klass");
}
// Verify siblings