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

equal deleted inserted replaced

-:9fdcc78b5398
+:1c7168ea0034
 * questions.
 *
 */
 #include "precompiled.hpp"
+#include "classfile/classFileParser.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/verifier.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "code/dependencyContext.hpp"
 #endif //  ndef DTRACE_ENABLED
 volatile int InstanceKlass::_total_instanceKlass_count = 0;
-InstanceKlass* InstanceKlass::allocate_instance_klass(
+static inline bool is_class_loader(const Symbol* class_name,
-ClassLoaderData* loader_data,
+const ClassFileParser& parser) {
-int vtable_len,
+assert(class_name != NULL, "invariant");
-int itable_len,
-int static_field_size,
+if (class_name == vmSymbols::java_lang_ClassLoader()) {
-int nonstatic_oop_map_size,
+return true;
-ReferenceType rt,
+}
-AccessFlags access_flags,
-Symbol* name,
+if (SystemDictionary::ClassLoader_klass_loaded()) {
-Klass* super_klass,
+const Klass* const super_klass = parser.super_klass();
-bool is_anonymous,
+if (super_klass != NULL) {
-TRAPS) {
+if (super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass())) {
+return true;
-int size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
+}
-access_flags.is_interface(), is_anonymous);
+}
+}
+return false;
+}
+InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) {
+const int size = InstanceKlass::size(parser.vtable_size(),
+parser.itable_size(),
+nonstatic_oop_map_size(parser.total_oop_map_count()),
+parser.is_interface(),
+parser.is_anonymous());
+const Symbol* const class_name = parser.class_name();
+assert(class_name != NULL, "invariant");
+ClassLoaderData* loader_data = parser.loader_data();
+assert(loader_data != NULL, "invariant");
+InstanceKlass* ik;
 // Allocation
-InstanceKlass* ik;
+if (REF_NONE == parser.reference_type()) {
-if (rt == REF_NONE) {
+if (class_name == vmSymbols::java_lang_Class()) {
-if (name == vmSymbols::java_lang_Class()) {
+// mirror
-ik = new (loader_data, size, THREAD) InstanceMirrorKlass(
+ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser);
-vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
+}
-access_flags, is_anonymous);
+else if (is_class_loader(class_name, parser)) {
-} else if (name == vmSymbols::java_lang_ClassLoader() ||
+// class loader
-(SystemDictionary::ClassLoader_klass_loaded() &&
+ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser);
-super_klass != NULL &&
+}
-super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) {
+else {
-ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(
+// normal
-vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
+ik = new (loader_data, size, THREAD) InstanceKlass(parser, InstanceKlass::_misc_kind_other);
-access_flags, is_anonymous);
+}
-} else {
+}
-// normal class
+else {
-ik = new (loader_data, size, THREAD) InstanceKlass(
+// reference
-vtable_len, itable_len, static_field_size, nonstatic_oop_map_size,
+ik = new (loader_data, size, THREAD) InstanceRefKlass(parser);
-InstanceKlass::_misc_kind_other, rt, access_flags, is_anonymous);
-}
-} else {
-// reference klass
-ik = new (loader_data, size, THREAD) InstanceRefKlass(
-vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
-access_flags, is_anonymous);
 }
 // Check for pending exception before adding to the loader data and incrementing
 // class count.  Can get OOM here.
 if (HAS_PENDING_EXCEPTION) {
 return NULL;
 }
+assert(ik != NULL, "invariant");
+const bool publicize = !parser.is_internal();
 // Add all classes to our internal class loader list here,
 // including classes in the bootstrap (NULL) class loader.
-loader_data->add_class(ik);
+loader_data->add_class(ik, publicize);
 Atomic::inc(&_total_instanceKlass_count);
 return ik;
 }
 // copy method ordering from resource area to Metaspace
-void InstanceKlass::copy_method_ordering(intArray* m, TRAPS) {
+void InstanceKlass::copy_method_ordering(const intArray* m, TRAPS) {
 if (m != NULL) {
 // allocate a new array and copy contents (memcpy?)
 _method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK);
 for (int i = 0; i < m->length(); i++) {
 _method_ordering->at_put(i, m->at(i));
 assert(default_vtable_indices() == NULL, "only create once");
 set_default_vtable_indices(vtable_indices);
 return vtable_indices;
 }
-InstanceKlass::InstanceKlass(int vtable_len,
+InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind) :
-int itable_len,
+_static_field_size(parser.static_field_size()),
-int static_field_size,
+_nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())),
-int nonstatic_oop_map_size,
+_vtable_len(parser.vtable_size()),
-unsigned kind,
+_itable_len(parser.itable_size()),
-ReferenceType rt,
+_reference_type(parser.reference_type()) {
-AccessFlags access_flags,
+set_kind(kind);
-bool is_anonymous) {
+set_access_flags(parser.access_flags());
-No_Safepoint_Verifier no_safepoint; // until k becomes parsable
+set_is_anonymous(parser.is_anonymous());
+set_layout_helper(Klass::instance_layout_helper(parser.layout_size(),
-int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
+false));
-access_flags.is_interface(), is_anonymous);
-set_vtable_length(vtable_len);
+assert(NULL == _methods, "underlying memory not zeroed?");
-set_itable_length(itable_len);
+assert(is_instance_klass(), "is layout incorrect?");
-set_static_field_size(static_field_size);
+assert(size_helper() == parser.layout_size(), "incorrect size_helper?");
-set_nonstatic_oop_map_size(nonstatic_oop_map_size);
+}
-set_access_flags(access_flags);
-_misc_flags = 0;  // initialize to zero
-set_kind(kind);
-set_is_anonymous(is_anonymous);
-assert(size() == iksize, "wrong size for object");
-set_array_klasses(NULL);
-set_methods(NULL);
-set_method_ordering(NULL);
-set_default_methods(NULL);
-set_default_vtable_indices(NULL);
-set_local_interfaces(NULL);
-set_transitive_interfaces(NULL);
-init_implementor();
-set_fields(NULL, 0);
-set_constants(NULL);
-set_class_loader_data(NULL);
-set_source_file_name_index(0);
-set_source_debug_extension(NULL, 0);
-set_array_name(NULL);
-set_inner_classes(NULL);
-set_static_oop_field_count(0);
-set_nonstatic_field_size(0);
-set_is_marked_dependent(false);
-_dep_context = DependencyContext::EMPTY;
-set_init_state(InstanceKlass::allocated);
-set_init_thread(NULL);
-set_reference_type(rt);
-set_oop_map_cache(NULL);
-set_jni_ids(NULL);
-set_osr_nmethods_head(NULL);
-set_breakpoints(NULL);
-init_previous_versions();
-set_generic_signature_index(0);
-release_set_methods_jmethod_ids(NULL);
-set_annotations(NULL);
-set_jvmti_cached_class_field_map(NULL);
-set_initial_method_idnum(0);
-set_jvmti_cached_class_field_map(NULL);
-set_cached_class_file(NULL);
-set_initial_method_idnum(0);
-set_minor_version(0);
-set_major_version(0);
-NOT_PRODUCT(_verify_count = 0;)
-// initialize the non-header words to zero
-intptr_t* p = (intptr_t*)this;
-for (int index = InstanceKlass::header_size(); index < iksize; index++) {
-p[index] = NULL_WORD;
-}
-// Set temporary value until parseClassFile updates it with the real instance
-// size.
-set_layout_helper(Klass::instance_layout_helper(0, true));
-}
 void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,
 Array<Method*>* methods) {
 if (methods != NULL && methods != Universe::the_empty_method_array() &&
 !methods->is_shared()) {
 MetadataFactory::free_array<Method*>(loader_data, methods);
 }
 }
 void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,
-Klass* super_klass,
+const Klass* super_klass,
 Array<Klass*>* local_interfaces,
 Array<Klass*>* transitive_interfaces) {
 // Only deallocate transitive interfaces if not empty, same as super class
 // or same as local interfaces.  See code in parseClassFile.
 Array<Klass*>* ti = transitive_interfaces;
 if (array_klasses() != NULL)
 ArrayKlass::cast(array_klasses())->array_klasses_do(f);
 }
 #ifdef ASSERT
-static int linear_search(Array<Method*>* methods, Symbol* name, Symbol* signature) {
+static int linear_search(const Array<Method*>* methods,
-int len = methods->length();
+const Symbol* name,
+const Symbol* signature) {
+const int len = methods->length();
 for (int index = 0; index < len; index++) {
-Method* m = methods->at(index);
+const Method* const m = methods->at(index);
 assert(m->is_method(), "must be method");
 if (m->signature() == signature && m->name() == name) {
 return index;
 }
 }
 return -1;
 }
 #endif
-static int binary_search(Array<Method*>* methods, Symbol* name) {
+static int binary_search(const Array<Method*>* methods, const Symbol* name) {
 int len = methods->length();
 // methods are sorted, so do binary search
 int l = 0;
 int h = len - 1;
 while (l <= h) {
 }
 return -1;
 }
 // find_method looks up the name/signature in the local methods array
-Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const {
+Method* InstanceKlass::find_method(const Symbol* name,
+const Symbol* signature) const {
 return find_method_impl(name, signature, find_overpass, find_static, find_private);
 }
-Method* InstanceKlass::find_method_impl(Symbol* name, Symbol* signature,
+Method* InstanceKlass::find_method_impl(const Symbol* name,
+const Symbol* signature,
 OverpassLookupMode overpass_mode,
 StaticLookupMode static_mode,
 PrivateLookupMode private_mode) const {
-return InstanceKlass::find_method_impl(methods(), name, signature, overpass_mode, static_mode, private_mode);
+return InstanceKlass::find_method_impl(methods(),
+name,
+signature,
+overpass_mode,
+static_mode,
+private_mode);
 }
 // find_instance_method looks up the name/signature in the local methods array
 // and skips over static methods
-Method* InstanceKlass::find_instance_method(
+Method* InstanceKlass::find_instance_method(const Array<Method*>* methods,
-Array<Method*>* methods, Symbol* name, Symbol* signature) {
+const Symbol* name,
-Method* meth = InstanceKlass::find_method_impl(methods, name, signature,
+const Symbol* signature) {
-find_overpass, skip_static, find_private);
+Method* const meth = InstanceKlass::find_method_impl(methods,
-assert(((meth == NULL) || !meth->is_static()), "find_instance_method should have skipped statics");
+name,
+signature,
+find_overpass,
+skip_static,
+find_private);
+assert(((meth == NULL) || !meth->is_static()),
+"find_instance_method should have skipped statics");
 return meth;
 }
 // find_instance_method looks up the name/signature in the local methods array
 // and skips over static methods
-Method* InstanceKlass::find_instance_method(Symbol* name, Symbol* signature) {
+Method* InstanceKlass::find_instance_method(const Symbol* name, const Symbol* signature) const {
 return InstanceKlass::find_instance_method(methods(), name, signature);
 }
 // Find looks up the name/signature in the local methods array
 // and filters on the overpass, static and private flags
 // This returns the first one found
 // note that the local methods array can have up to one overpass, one static
 // and one instance (private or not) with the same name/signature
-Method* InstanceKlass::find_local_method(Symbol* name, Symbol* signature,
+Method* InstanceKlass::find_local_method(const Symbol* name,
-OverpassLookupMode overpass_mode,
+const Symbol* signature,
-StaticLookupMode static_mode,
+OverpassLookupMode overpass_mode,
-PrivateLookupMode private_mode) const {
+StaticLookupMode static_mode,
-return InstanceKlass::find_method_impl(methods(), name, signature, overpass_mode, static_mode, private_mode);
+PrivateLookupMode private_mode) const {
+return InstanceKlass::find_method_impl(methods(),
+name,
+signature,
+overpass_mode,
+static_mode,
+private_mode);
 }
 // Find looks up the name/signature in the local methods array
 // and filters on the overpass, static and private flags
 // This returns the first one found
 // note that the local methods array can have up to one overpass, one static
 // and one instance (private or not) with the same name/signature
-Method* InstanceKlass::find_local_method(Array<Method*>* methods,
+Method* InstanceKlass::find_local_method(const Array<Method*>* methods,
-Symbol* name, Symbol* signature,
+const Symbol* name,
+const Symbol* signature,
+OverpassLookupMode overpass_mode,
+StaticLookupMode static_mode,
+PrivateLookupMode private_mode) {
+return InstanceKlass::find_method_impl(methods,
+name,
+signature,
+overpass_mode,
+static_mode,
+private_mode);
+}
+Method* InstanceKlass::find_method(const Array<Method*>* methods,
+const Symbol* name,
+const Symbol* signature) {
+return InstanceKlass::find_method_impl(methods,
+name,
+signature,
+find_overpass,
+find_static,
+find_private);
+}
+Method* InstanceKlass::find_method_impl(const Array<Method*>* methods,
+const Symbol* name,
+const Symbol* signature,
 OverpassLookupMode overpass_mode,
 StaticLookupMode static_mode,
 PrivateLookupMode private_mode) {
-return InstanceKlass::find_method_impl(methods, name, signature, overpass_mode, static_mode, private_mode);
-}
-// find_method looks up the name/signature in the local methods array
-Method* InstanceKlass::find_method(
-Array<Method*>* methods, Symbol* name, Symbol* signature) {
-return InstanceKlass::find_method_impl(methods, name, signature, find_overpass, find_static, find_private);
-}
-Method* InstanceKlass::find_method_impl(
-Array<Method*>* methods, Symbol* name, Symbol* signature,
-OverpassLookupMode overpass_mode, StaticLookupMode static_mode,
-PrivateLookupMode private_mode) {
 int hit = find_method_index(methods, name, signature, overpass_mode, static_mode, private_mode);
 return hit >= 0 ? methods->at(hit): NULL;
 }
-bool InstanceKlass::method_matches(Method* m, Symbol* signature, bool skipping_overpass, bool skipping_static, bool skipping_private) {
+// true if method matches signature and conforms to skipping_X conditions.
-return  ((m->signature() == signature) &&
+static bool method_matches(const Method* m,
-(!skipping_overpass || !m->is_overpass()) &&
+const Symbol* signature,
-(!skipping_static || !m->is_static()) &&
+bool skipping_overpass,
-(!skipping_private || !m->is_private()));
+bool skipping_static,
+bool skipping_private) {
+return ((m->signature() == signature) &&
+(!skipping_overpass || !m->is_overpass()) &&
+(!skipping_static || !m->is_static()) &&
+(!skipping_private || !m->is_private()));
 }
 // Used directly for default_methods to find the index into the
 // default_vtable_indices, and indirectly by find_method
 // find_method_index looks in the local methods array to return the index
 // There is the possibility in any _method's array to have the same name/signature
 // for a static method, an overpass method and a local instance method
 // To correctly catch a given method, the search criteria may need
 // to explicitly skip the other two. For local instance methods, it
 // is often necessary to skip private methods
-int InstanceKlass::find_method_index(
+int InstanceKlass::find_method_index(const Array<Method*>* methods,
-Array<Method*>* methods, Symbol* name, Symbol* signature,
+const Symbol* name,
-OverpassLookupMode overpass_mode, StaticLookupMode static_mode,
+const Symbol* signature,
-PrivateLookupMode private_mode) {
+OverpassLookupMode overpass_mode,
-bool skipping_overpass = (overpass_mode == skip_overpass);
+StaticLookupMode static_mode,
-bool skipping_static = (static_mode == skip_static);
+PrivateLookupMode private_mode) {
-bool skipping_private = (private_mode == skip_private);
+const bool skipping_overpass = (overpass_mode == skip_overpass);
-int hit = binary_search(methods, name);
+const bool skipping_static = (static_mode == skip_static);
+const bool skipping_private = (private_mode == skip_private);
+const int hit = binary_search(methods, name);
 if (hit != -1) {
-Method* m = methods->at(hit);
+const Method* const m = methods->at(hit);
 // Do linear search to find matching signature.  First, quick check
 // for common case, ignoring overpasses if requested.
-if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) return hit;
+if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) {
+return hit;
+}
 // search downwards through overloaded methods
 int i;
 for (i = hit - 1; i >= 0; --i) {
-Method* m = methods->at(i);
+const Method* const m = methods->at(i);
 assert(m->is_method(), "must be method");
-if (m->name() != name) break;
+if (m->name() != name) {
-if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) return i;
+break;
+}
+if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) {
+return i;
+}
 }
 // search upwards
 for (i = hit + 1; i < methods->length(); ++i) {
-Method* m = methods->at(i);
+const Method* const m = methods->at(i);
 assert(m->is_method(), "must be method");
-if (m->name() != name) break;
+if (m->name() != name) {
-if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) return i;
+break;
+}
+if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) {
+return i;
+}
 }
 // not found
 #ifdef ASSERT
-int index = (skipping_overpass || skipping_static || skipping_private) ? -1 : linear_search(methods, name, signature);
+const int index = (skipping_overpass || skipping_static || skipping_private) ? -1 :
-assert(index == -1, "binary search should have found entry %d", index);
+linear_search(methods, name, signature);
+assert(-1 == index, "binary search should have found entry %d", index);
 #endif
 }
 return -1;
 }
-int InstanceKlass::find_method_by_name(Symbol* name, int* end) {
+int InstanceKlass::find_method_by_name(const Symbol* name, int* end) const {
 return find_method_by_name(methods(), name, end);
 }
-int InstanceKlass::find_method_by_name(
+int InstanceKlass::find_method_by_name(const Array<Method*>* methods,
-Array<Method*>* methods, Symbol* name, int* end_ptr) {
+const Symbol* name,
+int* end_ptr) {
 assert(end_ptr != NULL, "just checking");
 int start = binary_search(methods, name);
 int end = start + 1;
 if (start != -1) {
 while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start;
 return -1;
 }
 // uncached_lookup_method searches both the local class methods array and all
 // superclasses methods arrays, skipping any overpass methods in superclasses.
-Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature, OverpassLookupMode overpass_mode) const {
+Method* InstanceKlass::uncached_lookup_method(const Symbol* name,
+const Symbol* signature,
+OverpassLookupMode overpass_mode) const {
 OverpassLookupMode overpass_local_mode = overpass_mode;
-Klass* klass = const_cast<InstanceKlass*>(this);
+const Klass* klass = this;
 while (klass != NULL) {
-Method* method = InstanceKlass::cast(klass)->find_method_impl(name, signature, overpass_local_mode, find_static, find_private);
+Method* const method = InstanceKlass::cast(klass)->find_method_impl(name,
+signature,
+overpass_local_mode,
+find_static,
+find_private);
 if (method != NULL) {
 return method;
 }
 klass = klass->super();
 overpass_local_mode = skip_overpass;   // Always ignore overpass methods in superclasses
 }
 #ifdef ASSERT
 // search through class hierarchy and return true if this class or
 // one of the superclasses was redefined
-bool InstanceKlass::has_redefined_this_or_super() {
+bool InstanceKlass::has_redefined_this_or_super() const {
-Klass* klass = this;
+const Klass* klass = this;
 while (klass != NULL) {
 if (InstanceKlass::cast(klass)->has_been_redefined()) {
 return true;
 }
 klass = klass->super();
 probe = jni_id_for_impl(this, offset);
 }
 return probe;
 }
-u2 InstanceKlass::enclosing_method_data(int offset) {
+u2 InstanceKlass::enclosing_method_data(int offset) const {
-Array<jushort>* inner_class_list = inner_classes();
+const Array<jushort>* const inner_class_list = inner_classes();
 if (inner_class_list == NULL) {
 return 0;
 }
-int length = inner_class_list->length();
+const int length = inner_class_list->length();
 if (length % inner_class_next_offset == 0) {
 return 0;
-} else {
+}
-int index = length - enclosing_method_attribute_size;
+const int index = length - enclosing_method_attribute_size;
 assert(offset < enclosing_method_attribute_size, "invalid offset");
 return inner_class_list->at(index + offset);
-}
 }
 void InstanceKlass::set_enclosing_method_indices(u2 class_index,
 u2 method_index) {
 Array<jushort>* inner_class_list = inner_classes();
 assert(_total_instanceKlass_count >= 1, "Sanity check");
 Atomic::dec(&_total_instanceKlass_count);
 }
-void InstanceKlass::set_source_debug_extension(char* array, int length) {
+void InstanceKlass::set_source_debug_extension(const char* array, int length) {
 if (array == NULL) {
 _source_debug_extension = NULL;
 } else {
 // Adding one to the attribute length in order to store a null terminator
 // character could cause an overflow because the attribute length is
 dest[dest_index] = '\0';
 return dest;
 }
 // different verisons of is_same_class_package
-bool InstanceKlass::is_same_class_package(Klass* class2) {
+bool InstanceKlass::is_same_class_package(const Klass* class2) const {
+const Klass* const class1 = (const Klass* const)this;
+oop classloader1 = InstanceKlass::cast(class1)->class_loader();
+const Symbol* const classname1 = class1->name();
 if (class2->is_objArray_klass()) {
 class2 = ObjArrayKlass::cast(class2)->bottom_klass();
 }
-oop classloader2 = class2->class_loader();
+oop classloader2;
-Symbol* classname2 = class2->name();
+if (class2->is_instance_klass()) {
+classloader2 = InstanceKlass::cast(class2)->class_loader();
-return InstanceKlass::is_same_class_package(class_loader(), name(),
+} else {
+assert(class2->is_typeArray_klass(), "should be type array");
+classloader2 = NULL;
+}
+const Symbol* classname2 = class2->name();
+return InstanceKlass::is_same_class_package(classloader1, classname1,
 classloader2, classname2);
 }
-bool InstanceKlass::is_same_class_package(oop classloader2, Symbol* classname2) {
+bool InstanceKlass::is_same_class_package(oop other_class_loader,
-return InstanceKlass::is_same_class_package(class_loader(), name(),
+const Symbol* other_class_name) const {
-classloader2, classname2);
+oop this_class_loader = class_loader();
+const Symbol* const this_class_name = name();
+return InstanceKlass::is_same_class_package(this_class_loader,
+this_class_name,
+other_class_loader,
+other_class_name);
 }
 // return true if two classes are in the same package, classloader
 // and classname information is enough to determine a class's package
-bool InstanceKlass::is_same_class_package(oop class_loader1, Symbol* class_name1,
+bool InstanceKlass::is_same_class_package(oop class_loader1, const Symbol* class_name1,
-oop class_loader2, Symbol* class_name2) {
+oop class_loader2, const Symbol* class_name2) {
 if (class_loader1 != class_loader2) {
 return false;
 } else if (class_name1 == class_name2) {
 return true;                // skip painful bytewise comparison
 } else {
 ...
 }
 */
 // tell if two classes have the same enclosing class (at package level)
-bool InstanceKlass::is_same_package_member_impl(instanceKlassHandle class1,
+bool InstanceKlass::is_same_package_member_impl(const InstanceKlass* class1,
-Klass* class2_oop, TRAPS) {
+const Klass* class2,
-if (class2_oop == class1())                       return true;
+TRAPS) {
-if (!class2_oop->is_instance_klass())  return false;
+if (class2 == class1) return true;
-instanceKlassHandle class2(THREAD, class2_oop);
+if (!class2->is_instance_klass())  return false;
 // must be in same package before we try anything else
 if (!class1->is_same_class_package(class2->class_loader(), class2->name()))
 return false;
 // As long as there is an outer1.getEnclosingClass,
 // shift the search outward.
-instanceKlassHandle outer1 = class1;
+const InstanceKlass* outer1 = class1;
 for (;;) {
 // As we walk along, look for equalities between outer1 and class2.
 // Eventually, the walks will terminate as outer1 stops
 // at the top-level class around the original class.
 bool ignore_inner_is_member;
-Klass* next = outer1->compute_enclosing_class(&ignore_inner_is_member,
+const Klass* next = outer1->compute_enclosing_class(&ignore_inner_is_member,
 CHECK_false);
 if (next == NULL)  break;
-if (next == class2())  return true;
+if (next == class2)  return true;
-outer1 = instanceKlassHandle(THREAD, next);
+outer1 = InstanceKlass::cast(next);
 }
 // Now do the same for class2.
-instanceKlassHandle outer2 = class2;
+const InstanceKlass* outer2 = InstanceKlass::cast(class2);
 for (;;) {
 bool ignore_inner_is_member;
 Klass* next = outer2->compute_enclosing_class(&ignore_inner_is_member,
 CHECK_false);
 if (next == NULL)  break;
 // Might as well check the new outer against all available values.
-if (next == class1())  return true;
+if (next == class1)  return true;
-if (next == outer1())  return true;
+if (next == outer1)  return true;
-outer2 = instanceKlassHandle(THREAD, next);
+outer2 = InstanceKlass::cast(next);
 }
 // If by this point we have not found an equality between the
 // two classes, we know they are in separate package members.
 return false;
 }
 }
 return false;
 }
-Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k, bool* inner_is_member, TRAPS) {
+InstanceKlass* InstanceKlass::compute_enclosing_class_impl(const InstanceKlass* k,
-instanceKlassHandle outer_klass;
+bool* inner_is_member,
+TRAPS) {
+InstanceKlass* outer_klass = NULL;
 *inner_is_member = false;
 int ooff = 0, noff = 0;
 if (find_inner_classes_attr(k, &ooff, &noff, THREAD)) {
 constantPoolHandle i_cp(THREAD, k->constants());
 if (ooff != 0) {
 Klass* ok = i_cp->klass_at(ooff, CHECK_NULL);
-outer_klass = instanceKlassHandle(THREAD, ok);
+outer_klass = InstanceKlass::cast(ok);
 *inner_is_member = true;
 }
-if (outer_klass.is_null()) {
+if (NULL == outer_klass) {
 // It may be anonymous; try for that.
 int encl_method_class_idx = k->enclosing_method_class_index();
 if (encl_method_class_idx != 0) {
 Klass* ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL);
-outer_klass = instanceKlassHandle(THREAD, ok);
+outer_klass = InstanceKlass::cast(ok);
 *inner_is_member = false;
 }
 }
 }
 // If no inner class attribute found for this class.
-if (outer_klass.is_null())  return NULL;
+if (NULL == outer_klass) return NULL;
 // Throws an exception if outer klass has not declared k as an inner klass
 // We need evidence that each klass knows about the other, or else
 // the system could allow a spoof of an inner class to gain access rights.
 Reflection::check_for_inner_class(outer_klass, k, *inner_is_member, CHECK_NULL);
-return outer_klass();
+return outer_klass;
 }
 jint InstanceKlass::compute_modifier_flags(TRAPS) const {
 jint access = access_flags().as_int();

changeset 34666	1c7168ea0034
parent 34629	d1e1bfdca413
child 35061	be6025ebffea