jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceKlass.cpp

equal deleted inserted replaced

-:8cc4189d9a2a
+:f4872ef5df09
 // abort if the super class should be initialized
 if (!InstanceKlass::cast(super)->is_initialized()) return;
 // call body to expose the this pointer
-instanceKlassHandle this_oop(thread, this);
+instanceKlassHandle this_k(thread, this);
-eager_initialize_impl(this_oop);
+eager_initialize_impl(this_k);
 }
 }
 // JVMTI spec thinks there are signers and protection domain in the
 // instanceKlass.  These accessors pretend these fields are there.
 OrderAccess::storestore();
 java_lang_Class::set_init_lock(java_mirror(), NULL);
 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()
+if (!this_k->is_not_initialized()) return;  // note: not equivalent to is_initialized()
-ClassState old_state = this_oop->init_state();
+ClassState old_state = this_k->init_state();
-link_class_impl(this_oop, true, THREAD);
+link_class_impl(this_k, true, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 // Abort if linking the class throws an exception.
 // 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 )
+if( old_state != this_k->_init_state )
-this_oop->set_init_state (old_state);
+this_k->set_init_state (old_state);
 } else {
 // linking successfull, mark class as initialized
-this_oop->set_init_state (fully_initialized);
+this_k->set_init_state (fully_initialized);
-this_oop->fence_and_clear_init_lock();
+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());
 }
 }
 }
 // process. The step comments refers to the procedure described in that section.
 // Note: implementation moved to static method to expose the this pointer.
 void InstanceKlass::initialize(TRAPS) {
 if (this->should_be_initialized()) {
 HandleMark hm(THREAD);
-instanceKlassHandle this_oop(THREAD, this);
+instanceKlassHandle this_k(THREAD, this);
-initialize_impl(this_oop, CHECK);
+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!
 } else {
 assert(is_initialized(), "sanity check");
 }
 }
 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);
 }
 // Used exclusively by the shared spaces dump mechanism to prevent
 // classes mapped into the shared regions in new VMs from appearing linked.
 void InstanceKlass::link_class(TRAPS) {
 assert(is_loaded(), "must be loaded");
 if (!is_linked()) {
 HandleMark hm(THREAD);
-instanceKlassHandle this_oop(THREAD, this);
+instanceKlassHandle this_k(THREAD, this);
-link_class_impl(this_oop, true, CHECK);
+link_class_impl(this_k, true, CHECK);
 }
 }
 // Called to verify that a class can link during initialization, without
 // throwing a VerifyError.
 bool InstanceKlass::link_class_or_fail(TRAPS) {
 assert(is_loaded(), "must be loaded");
 if (!is_linked()) {
 HandleMark hm(THREAD);
-instanceKlassHandle this_oop(THREAD, this);
+instanceKlassHandle this_k(THREAD, this);
-link_class_impl(this_oop, false, CHECK_false);
+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;
 }
 // Timing
 // timer handles recursion
 assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl");
 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);
 Exceptions::fthrow(
 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;
 }
 link_class_impl(super, throw_verifyerror, CHECK_false);
 }
 // 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);
 instanceKlassHandle ih(THREAD, interfaces->at(index));
 link_class_impl(ih, throw_verifyerror, CHECK_false);
 }
 // 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;
 }
 // trace only the link time for this klass that includes
 // the verification time
 jt->get_thread_stat()->perf_timers_addr(),
 PerfClassTraceTime::CLASS_LINK);
 // 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_k->is_linked()) {
-if (!this_oop->is_rewritten()) {
+if (!this_k->is_rewritten()) {
 {
 // Timer includes any side effects of class verification (resolution,
 // etc), but not recursive entry into verify_code().
 PerfClassTraceTime timer(ClassLoader::perf_class_verify_time(),
 ClassLoader::perf_class_verify_selftime(),
 ClassLoader::perf_classes_verified(),
 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;
 }
 }
 // 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_k->vtable()->initialize_vtable(true, CHECK_false);
-this_oop->itable()->initialize_itable(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());
 }
 }
 }
 return true;
 }
 // Rewrite the byte codes of all of the methods of a class.
 // The rewriter must be called exactly once. Rewriting must happen after
 // 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);
+instanceKlassHandle this_k(THREAD, this);
-if (this_oop->is_rewritten()) {
+if (this_k->is_rewritten()) {
-assert(this_oop()->is_shared(), "rewriting an unshared class?");
+assert(this_k()->is_shared(), "rewriting an unshared class?");
 return;
 }
-Rewriter::rewrite(this_oop, CHECK);
+Rewriter::rewrite(this_k, CHECK);
-this_oop->set_rewritten();
+this_k->set_rewritten();
 }
 // Now relocate and link method entry points after class is rewritten.
 // This is outside is_rewritten flag. In case of an exception, it can be
 // executed more than once.
 #endif //ASSERT
 }
 }
-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);
+this_k->link_class(CHECK);
-DTRACE_CLASSINIT_PROBE(required, InstanceKlass::cast(this_oop()), -1);
+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
 // Step 2
 // 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)) {
+if (this_k->is_being_initialized() && this_k->is_reentrant_initialization(self)) {
-DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_oop()), -1,wait);
+DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_k()), -1,wait);
 return;
 }
 // Step 4
-if (this_oop->is_initialized()) {
+if (this_k->is_initialized()) {
-DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_oop()), -1,wait);
+DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_k()), -1,wait);
 return;
 }
 // Step 5
-if (this_oop->is_in_error_state()) {
+if (this_k->is_in_error_state()) {
-DTRACE_CLASSINIT_PROBE_WAIT(erroneous, InstanceKlass::cast(this_oop()), -1,wait);
+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) {
 // Out of memory: can't create detailed error message
 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className);
 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message);
 }
 }
 // Step 6
-this_oop->set_init_state(being_initialized);
+this_k->set_init_state(being_initialized);
-this_oop->set_init_thread(self);
+this_k->set_init_thread(self);
 }
 // Step 7
-Klass* super_klass = this_oop->super();
+Klass* super_klass = this_k->super();
-if (super_klass != NULL && !this_oop->is_interface() && super_klass->should_be_initialized()) {
+if (super_klass != NULL && !this_k->is_interface() && super_klass->should_be_initialized()) {
 super_klass->initialize(THREAD);
 if (HAS_PENDING_EXCEPTION) {
 Handle e(THREAD, PENDING_EXCEPTION);
 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) {
+for (int i = 0; i < this_k->local_interfaces()->length(); ++i) {
-Klass* iface = this_oop->local_interfaces()->at(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);
 if (HAS_PENDING_EXCEPTION) {
 Handle e(THREAD, PENDING_EXCEPTION);
 CLEAR_PENDING_EXCEPTION;
 {
 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
 // thrown below
 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());
 }
 }
 }
 }
 // Step 8
 {
 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(),
 ClassLoader::perf_class_init_selftime(),
 ClassLoader::perf_classes_inited(),
 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 {
 // Step 10 and 11
 Handle e(THREAD, PENDING_EXCEPTION);
 // JVMTI has already reported the pending exception
 // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError
 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 {
 JavaCallArguments args(e);
 THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(),
 vmSymbols::throwable_void_signature(),
 &args);
 }
 }
-DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_oop()), -1,wait);
+DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_k()), -1,wait);
 }
 // Note: implementation moved to static method to expose the this pointer.
 void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) {
 instanceKlassHandle kh(THREAD, this);
 set_initialization_state_and_notify_impl(kh, state, CHECK);
 }
-void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {
+void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_k, ClassState state, TRAPS) {
-oop init_lock = this_oop->init_lock();
+oop init_lock = this_k->init_lock();
 ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
-this_oop->set_init_state(state);
+this_k->set_init_state(state);
-this_oop->fence_and_clear_init_lock();
+this_k->fence_and_clear_init_lock();
 ol.notify_all(CHECK);
 }
 // The embedded _implementor field can only record one implementor.
 // When there are more than one implementors, the _implementor field
 }
 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);
 }
 }
 bool InstanceKlass::can_be_primary_super_slow() const {
 if (is_interface())
 : vmSymbols::java_lang_IllegalAccessException(), external_name());
 }
 }
 Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) {
-instanceKlassHandle this_oop(THREAD, this);
+instanceKlassHandle this_k(THREAD, this);
-return array_klass_impl(this_oop, or_null, n, THREAD);
+return array_klass_impl(this_k, or_null, n, THREAD);
 }
-Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_null, int n, TRAPS) {
+Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_k, bool or_null, int n, TRAPS) {
-if (this_oop->array_klasses() == NULL) {
+if (this_k->array_klasses() == NULL) {
 if (or_null) return NULL;
 ResourceMark rm;
 JavaThread *jt = (JavaThread *)THREAD;
 {
 // Atomic creation of array_klasses
 MutexLocker mc(Compile_lock, THREAD);   // for vtables
 MutexLocker ma(MultiArray_lock, THREAD);
 // Check if update has already taken place
-if (this_oop->array_klasses() == NULL) {
+if (this_k->array_klasses() == NULL) {
-Klass*    k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
+Klass*    k = ObjArrayKlass::allocate_objArray_klass(this_k->class_loader_data(), 1, this_k, CHECK_NULL);
-this_oop->set_array_klasses(k);
+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);
 }
 return oak->array_klass(n, CHECK_NULL);
 }
 return clinit;
 }
 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());
+methodHandle h_method(THREAD, this_k->class_initializer());
-assert(!this_oop->is_initialized(), "we cannot initialize twice");
+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();
+this_k->name()->print_value();
-tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_oop());
+tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_k());
 }
 if (h_method() != NULL) {
 JavaCallArguments args; // No arguments
 JavaValue result(T_VOID);
 JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args)
 instanceKlassHandle h_this(THREAD, this);
 do_local_static_fields_impl(h_this, f, CHECK);
 }
-void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
+void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_k, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
-for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) {
+for (JavaFieldStream fs(this_k()); !fs.done(); fs.next()) {
 if (fs.access_flags().is_static()) {
 fieldDescriptor& fd = fs.field_descriptor();
 f(&fd, CHECK);
 }
 }
 }
 return NULL;
 }
 /* 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());
+probe = new JNIid(this_k(), offset, this_k->jni_ids());
-this_oop->set_jni_ids(probe);
+this_k->set_jni_ids(probe);
 }
 return probe;
 }
 // always seemed a valid generalization.  (DLD -- 6/00)
 vtable()->verify(st);
 }
 // Verify first subklass
-if (subklass_oop() != NULL) {
+if (subklass() != NULL) {
-guarantee(subklass_oop()->is_klass(), "should be klass");
+guarantee(subklass()->is_klass(), "should be klass");
 }
 // Verify siblings
 Klass* super = this->super();
 Klass* sib = next_sibling();

changeset 23515	f4872ef5df09
parent 22929	cb114f3238ef
child 23845	ebd1fafcc362
child 23872	536c66fc43d3