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

equal deleted inserted replaced

-:2e7898927798
+:979ebd346ecf
 /*
-* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 assert(!is_not_initialized(), "class must be initialized now");
 }
 void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_k) {
 EXCEPTION_MARK;
-oop init_lock = this_k->init_lock();
+HandleMark hm(THREAD);
-ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
+Handle init_lock(THREAD, this_k->init_lock());
+ObjectLocker ol(init_lock, THREAD, init_lock() != NULL);
 // abort if someone beat us to the initialization
 if (!this_k->is_not_initialized()) return;  // note: not equivalent to is_initialized()
 ClassState old_state = this_k->init_state();
 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization
 // 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_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!
 }
 void InstanceKlass::link_class(TRAPS) {
 assert(is_loaded(), "must be loaded");
 if (!is_linked()) {
-HandleMark hm(THREAD);
 instanceKlassHandle this_k(THREAD, this);
 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_k(THREAD, this);
 link_class_impl(this_k, false, CHECK_false);
 }
 return is_linked();
 }
 // link all interfaces implemented by this class before linking this class
 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
 jt->get_thread_stat()->perf_timers_addr(),
 PerfClassTraceTime::CLASS_LINK);
 // verification & rewriting
 {
-oop init_lock = this_k->init_lock();
+HandleMark hm(THREAD);
-ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
+Handle init_lock(THREAD, 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_k->is_linked()) {
 if (!this_k->is_rewritten()) {
 {
 bool verify_ok = verify_code(this_k, throw_verifyerror, THREAD);
 }
 }
 }
 void InstanceKlass::initialize_impl(instanceKlassHandle this_k, TRAPS) {
+HandleMark hm(THREAD);
 // Make sure klass is linked (verified) before initialization
 // A class could already be verified, since it has been reflected upon.
 this_k->link_class(CHECK);
 DTRACE_CLASSINIT_PROBE(required, this_k(), -1);
 bool wait = false;
 // refer to the JVM book page 47 for description of steps
 // Step 1
 {
-oop init_lock = this_k->init_lock();
+Handle init_lock(THREAD, this_k->init_lock());
-ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
+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
 instanceKlassHandle kh(THREAD, this);
 set_initialization_state_and_notify_impl(kh, state, CHECK);
 }
 void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_k, ClassState state, TRAPS) {
-oop init_lock = this_k->init_lock();
+Handle init_lock(THREAD, this_k->init_lock());
-if (init_lock != NULL) {
+if (init_lock() != NULL) {
 ObjectLocker ol(init_lock, THREAD);
 this_k->set_init_state(state);
 this_k->fence_and_clear_init_lock();
 ol.notify_all(CHECK);
 } else {
-assert(init_lock != NULL, "The initialization state should never be set twice");
+assert(init_lock() != NULL, "The initialization state should never be set twice");
 this_k->set_init_state(state);
 }
 }
 // The embedded _implementor field can only record one implementor.
 }
 void InstanceKlass::set_package(ClassLoaderData* loader_data, TRAPS) {
 // ensure java/ packages only loaded by boot or platform builtin loaders
-check_prohibited_package(name(), loader_data->class_loader(), CHECK);
+Handle class_loader(THREAD, loader_data->class_loader());
+check_prohibited_package(name(), class_loader, CHECK);
 TempNewSymbol pkg_name = package_from_name(name(), CHECK);
 if (pkg_name != NULL && loader_data != NULL) {
 void InstanceKlass::check_prohibited_package(Symbol* class_name,
 Handle class_loader,
 TRAPS) {
 ResourceMark rm(THREAD);
 if (!class_loader.is_null() &&
-!SystemDictionary::is_platform_class_loader(class_loader) &&
+!SystemDictionary::is_platform_class_loader(class_loader()) &&
 class_name != NULL &&
 strncmp(class_name->as_C_string(), JAVAPKG, JAVAPKG_LEN) == 0) {
 TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK);
 assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'");
 char* name = pkg_name->as_C_string();
 log->print(" source: instance of %s", caller->external_name());
 } else {
 // source is unknown
 }
 } else {
-Handle class_loader(loader_data->class_loader());
+oop class_loader = loader_data->class_loader();
 log->print(" source: %s", class_loader->klass()->external_name());
 }
 } else {
 log->print(" source: shared objects file");
 }

changeset 46271	979ebd346ecf
parent 42650	1f304d0c888b
child 46289	1904e7ec236e