21 * questions. |
21 * questions. |
22 * |
22 * |
23 */ |
23 */ |
24 |
24 |
25 #include "precompiled.hpp" |
25 #include "precompiled.hpp" |
|
26 #include "aot/aotLoader.hpp" |
26 #include "classfile/classFileParser.hpp" |
27 #include "classfile/classFileParser.hpp" |
27 #include "classfile/classFileStream.hpp" |
28 #include "classfile/classFileStream.hpp" |
|
29 #include "classfile/classLoader.hpp" |
28 #include "classfile/javaClasses.hpp" |
30 #include "classfile/javaClasses.hpp" |
29 #include "classfile/moduleEntry.hpp" |
31 #include "classfile/moduleEntry.hpp" |
30 #include "classfile/systemDictionary.hpp" |
32 #include "classfile/systemDictionary.hpp" |
31 #include "classfile/systemDictionaryShared.hpp" |
33 #include "classfile/systemDictionaryShared.hpp" |
32 #include "classfile/verifier.hpp" |
34 #include "classfile/verifier.hpp" |
143 InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) { |
145 InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) { |
144 const int size = InstanceKlass::size(parser.vtable_size(), |
146 const int size = InstanceKlass::size(parser.vtable_size(), |
145 parser.itable_size(), |
147 parser.itable_size(), |
146 nonstatic_oop_map_size(parser.total_oop_map_count()), |
148 nonstatic_oop_map_size(parser.total_oop_map_count()), |
147 parser.is_interface(), |
149 parser.is_interface(), |
148 parser.is_anonymous()); |
150 parser.is_anonymous(), |
|
151 should_store_fingerprint()); |
149 |
152 |
150 const Symbol* const class_name = parser.class_name(); |
153 const Symbol* const class_name = parser.class_name(); |
151 assert(class_name != NULL, "invariant"); |
154 assert(class_name != NULL, "invariant"); |
152 ClassLoaderData* loader_data = parser.loader_data(); |
155 ClassLoaderData* loader_data = parser.loader_data(); |
153 assert(loader_data != NULL, "invariant"); |
156 assert(loader_data != NULL, "invariant"); |
786 THROW_OOP(e()); |
789 THROW_OOP(e()); |
787 } |
790 } |
788 } |
791 } |
789 |
792 |
790 |
793 |
|
794 // Look for aot compiled methods for this klass, including class initializer. |
|
795 AOTLoader::load_for_klass(this_k, THREAD); |
|
796 |
791 // Step 8 |
797 // Step 8 |
792 { |
798 { |
793 assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl"); |
799 assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl"); |
794 JavaThread* jt = (JavaThread*)THREAD; |
800 JavaThread* jt = (JavaThread*)THREAD; |
795 DTRACE_CLASSINIT_PROBE_WAIT(clinit, this_k(), -1,wait); |
801 DTRACE_CLASSINIT_PROBE_WAIT(clinit, this_k(), -1,wait); |
1949 mdo->clean_method_data(is_alive); |
1955 mdo->clean_method_data(is_alive); |
1950 } |
1956 } |
1951 } |
1957 } |
1952 } |
1958 } |
1953 |
1959 |
|
1960 bool InstanceKlass::supers_have_passed_fingerprint_checks() { |
|
1961 if (java_super() != NULL && !java_super()->has_passed_fingerprint_check()) { |
|
1962 ResourceMark rm; |
|
1963 log_trace(class, fingerprint)("%s : super %s not fingerprinted", external_name(), java_super()->external_name()); |
|
1964 return false; |
|
1965 } |
|
1966 |
|
1967 Array<Klass*>* local_interfaces = this->local_interfaces(); |
|
1968 if (local_interfaces != NULL) { |
|
1969 int length = local_interfaces->length(); |
|
1970 for (int i = 0; i < length; i++) { |
|
1971 InstanceKlass* intf = InstanceKlass::cast(local_interfaces->at(i)); |
|
1972 if (!intf->has_passed_fingerprint_check()) { |
|
1973 ResourceMark rm; |
|
1974 log_trace(class, fingerprint)("%s : interface %s not fingerprinted", external_name(), intf->external_name()); |
|
1975 return false; |
|
1976 } |
|
1977 } |
|
1978 } |
|
1979 |
|
1980 return true; |
|
1981 } |
|
1982 |
|
1983 bool InstanceKlass::should_store_fingerprint() { |
|
1984 #if INCLUDE_AOT |
|
1985 // We store the fingerprint into the InstanceKlass only in the following 2 cases: |
|
1986 if (EnableJVMCI && !UseJVMCICompiler) { |
|
1987 // (1) We are running AOT to generate a shared library. |
|
1988 return true; |
|
1989 } |
|
1990 if (DumpSharedSpaces) { |
|
1991 // (2) We are running -Xshare:dump to create a shared archive |
|
1992 return true; |
|
1993 } |
|
1994 #endif |
|
1995 |
|
1996 // In all other cases we might set the _misc_has_passed_fingerprint_check bit, |
|
1997 // but do not store the 64-bit fingerprint to save space. |
|
1998 return false; |
|
1999 } |
|
2000 |
|
2001 bool InstanceKlass::has_stored_fingerprint() const { |
|
2002 #if INCLUDE_AOT |
|
2003 return should_store_fingerprint() || is_shared(); |
|
2004 #else |
|
2005 return false; |
|
2006 #endif |
|
2007 } |
|
2008 |
|
2009 uint64_t InstanceKlass::get_stored_fingerprint() const { |
|
2010 address adr = adr_fingerprint(); |
|
2011 if (adr != NULL) { |
|
2012 return (uint64_t)Bytes::get_native_u8(adr); // adr may not be 64-bit aligned |
|
2013 } |
|
2014 return 0; |
|
2015 } |
|
2016 |
|
2017 void InstanceKlass::store_fingerprint(uint64_t fingerprint) { |
|
2018 address adr = adr_fingerprint(); |
|
2019 if (adr != NULL) { |
|
2020 Bytes::put_native_u8(adr, (u8)fingerprint); // adr may not be 64-bit aligned |
|
2021 |
|
2022 ResourceMark rm; |
|
2023 log_trace(class, fingerprint)("stored as " PTR64_FORMAT " for class %s", fingerprint, external_name()); |
|
2024 } |
|
2025 } |
1954 |
2026 |
1955 static void remove_unshareable_in_class(Klass* k) { |
2027 static void remove_unshareable_in_class(Klass* k) { |
1956 // remove klass's unshareable info |
2028 // remove klass's unshareable info |
1957 k->remove_unshareable_info(); |
2029 k->remove_unshareable_info(); |
1958 } |
2030 } |