956
957 // Quick range check for names of well-known classes:
958 static Symbol* wk_klass_name_limits[2] = {NULL, NULL};
959
960 #ifndef PRODUCT
961 static int find_wkk_calls, find_wkk_probes, find_wkk_wins;
962 // counts for "hello world": 3983, 1616, 1075
963 // => 60% hit after limit guard, 25% total win rate
964 #endif
965
966 Klass* SystemDictionary::find_well_known_klass(Symbol* class_name) {
967 // A bounds-check on class_name will quickly get a negative result.
968 NOT_PRODUCT(find_wkk_calls++);
969 if (class_name >= wk_klass_name_limits[0] &&
970 class_name <= wk_klass_name_limits[1]) {
971 NOT_PRODUCT(find_wkk_probes++);
972 vmSymbols::SID sid = vmSymbols::find_sid(class_name);
973 if (sid != vmSymbols::NO_SID) {
974 Klass* k = NULL;
975 switch (sid) {
976 #define WK_KLASS_CASE(name, symbol, ignore_option) \
977 case vmSymbols::VM_SYMBOL_ENUM_NAME(symbol): \
978 k = WK_KLASS(name); break;
979 WK_KLASSES_DO(WK_KLASS_CASE)
980 #undef WK_KLASS_CASE
981 }
982 NOT_PRODUCT(if (k != NULL) find_wkk_wins++);
983 return k;
984 }
985 }
986 return NULL;
987 }
988
989 // Note: this method is much like resolve_from_stream, but
990 // updates no supplemental data structures.
991 // TODO consolidate the two methods with a helper routine?
992 Klass* SystemDictionary::parse_stream(Symbol* class_name,
993 Handle class_loader,
994 Handle protection_domain,
995 ClassFileStream* st,
996 KlassHandle host_klass,
997 GrowableArray<Handle>* cp_patches,
998 TRAPS) {
1938 int sid = (info >> CEIL_LG_OPTION_LIMIT);
1939 int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT));
1940
1941 initialize_wk_klass((WKID)id, opt, CHECK);
1942
1943 // Update limits, so find_well_known_klass can be very fast:
1944 Symbol* s = vmSymbols::symbol_at((vmSymbols::SID)sid);
1945 if (wk_klass_name_limits[1] == NULL) {
1946 wk_klass_name_limits[0] = wk_klass_name_limits[1] = s;
1947 } else if (wk_klass_name_limits[1] < s) {
1948 wk_klass_name_limits[1] = s;
1949 } else if (wk_klass_name_limits[0] > s) {
1950 wk_klass_name_limits[0] = s;
1951 }
1952 }
1953
1954 // move the starting value forward to the limit:
1955 start_id = limit_id;
1956 }
1957
1958
1959 void SystemDictionary::initialize_preloaded_classes(TRAPS) {
1960 assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once");
1961 // Preload commonly used klasses
1962 WKID scan = FIRST_WKID;
1963 // first do Object, then String, Class
1964 if (UseSharedSpaces) {
1965 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK);
1966 // Initialize the constant pool for the Object_class
1967 InstanceKlass* ik = InstanceKlass::cast(Object_klass());
1968 ik->constants()->restore_unshareable_info(CHECK);
1969 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
1970 } else {
1971 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
1972 }
1973
1974 // Calculate offsets for String and Class classes since they are loaded and
1975 // can be used after this point.
1976 java_lang_String::compute_offsets();
1977 java_lang_Class::compute_offsets();
1993
1994 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK);
1995 InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
1996 InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK);
1997 InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL);
1998 InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM);
1999
2000 // JSR 292 classes
2001 WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass);
2002 WKID jsr292_group_end = WK_KLASS_ENUM_NAME(VolatileCallSite_klass);
2003 initialize_wk_klasses_until(jsr292_group_start, scan, CHECK);
2004 if (EnableInvokeDynamic) {
2005 initialize_wk_klasses_through(jsr292_group_end, scan, CHECK);
2006 } else {
2007 // Skip the JSR 292 classes, if not enabled.
2008 scan = WKID(jsr292_group_end + 1);
2009 }
2010
2011 initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK);
2012
2013 _box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass);
2014 _box_klasses[T_CHAR] = WK_KLASS(Character_klass);
2015 _box_klasses[T_FLOAT] = WK_KLASS(Float_klass);
2016 _box_klasses[T_DOUBLE] = WK_KLASS(Double_klass);
2017 _box_klasses[T_BYTE] = WK_KLASS(Byte_klass);
2018 _box_klasses[T_SHORT] = WK_KLASS(Short_klass);
2019 _box_klasses[T_INT] = WK_KLASS(Integer_klass);
2020 _box_klasses[T_LONG] = WK_KLASS(Long_klass);
2021 //_box_klasses[T_OBJECT] = WK_KLASS(object_klass);
2022 //_box_klasses[T_ARRAY] = WK_KLASS(object_klass);
2023
2024 #ifdef KERNEL
2025 if (DownloadManager_klass() == NULL) {
2026 warning("Cannot find sun/jkernel/DownloadManager");
2027 }
2028 #endif // KERNEL
2029
2030 { // Compute whether we should use loadClass or loadClassInternal when loading classes.
2031 Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
2032 _has_loadClassInternal = (method != NULL);
|
956
957 // Quick range check for names of well-known classes:
958 static Symbol* wk_klass_name_limits[2] = {NULL, NULL};
959
960 #ifndef PRODUCT
961 static int find_wkk_calls, find_wkk_probes, find_wkk_wins;
962 // counts for "hello world": 3983, 1616, 1075
963 // => 60% hit after limit guard, 25% total win rate
964 #endif
965
966 Klass* SystemDictionary::find_well_known_klass(Symbol* class_name) {
967 // A bounds-check on class_name will quickly get a negative result.
968 NOT_PRODUCT(find_wkk_calls++);
969 if (class_name >= wk_klass_name_limits[0] &&
970 class_name <= wk_klass_name_limits[1]) {
971 NOT_PRODUCT(find_wkk_probes++);
972 vmSymbols::SID sid = vmSymbols::find_sid(class_name);
973 if (sid != vmSymbols::NO_SID) {
974 Klass* k = NULL;
975 switch (sid) {
976 #define WK_KLASS_CASE(name, symbol, option) \
977 case vmSymbols::VM_SYMBOL_ENUM_NAME(symbol): \
978 if (option == Pre_Link) { \
979 k = WK_KLASS(name); \
980 } \
981 break;
982 WK_KLASSES_DO(WK_KLASS_CASE)
983 #undef WK_KLASS_CASE
984 }
985 NOT_PRODUCT(if (k != NULL) find_wkk_wins++);
986 return k;
987 }
988 }
989 return NULL;
990 }
991
992 // Note: this method is much like resolve_from_stream, but
993 // updates no supplemental data structures.
994 // TODO consolidate the two methods with a helper routine?
995 Klass* SystemDictionary::parse_stream(Symbol* class_name,
996 Handle class_loader,
997 Handle protection_domain,
998 ClassFileStream* st,
999 KlassHandle host_klass,
1000 GrowableArray<Handle>* cp_patches,
1001 TRAPS) {
1941 int sid = (info >> CEIL_LG_OPTION_LIMIT);
1942 int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT));
1943
1944 initialize_wk_klass((WKID)id, opt, CHECK);
1945
1946 // Update limits, so find_well_known_klass can be very fast:
1947 Symbol* s = vmSymbols::symbol_at((vmSymbols::SID)sid);
1948 if (wk_klass_name_limits[1] == NULL) {
1949 wk_klass_name_limits[0] = wk_klass_name_limits[1] = s;
1950 } else if (wk_klass_name_limits[1] < s) {
1951 wk_klass_name_limits[1] = s;
1952 } else if (wk_klass_name_limits[0] > s) {
1953 wk_klass_name_limits[0] = s;
1954 }
1955 }
1956
1957 // move the starting value forward to the limit:
1958 start_id = limit_id;
1959 }
1960
1961 #ifdef ASSERT
1962 void SystemDictionary::check_wk_pre_link_klasses() {
1963 #define WK_KLASS_CHECK(name, symbol, option) \
1964 if (option == Pre_Link) { \
1965 assert(name()->is_public(), ""); \
1966 }
1967 WK_KLASSES_DO(WK_KLASS_CHECK);
1968 #undef WK_KLASS_CHECK
1969 }
1970 #endif
1971
1972 void SystemDictionary::initialize_preloaded_classes(TRAPS) {
1973 assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once");
1974 // Preload commonly used klasses
1975 WKID scan = FIRST_WKID;
1976 // first do Object, then String, Class
1977 if (UseSharedSpaces) {
1978 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK);
1979 // Initialize the constant pool for the Object_class
1980 InstanceKlass* ik = InstanceKlass::cast(Object_klass());
1981 ik->constants()->restore_unshareable_info(CHECK);
1982 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
1983 } else {
1984 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
1985 }
1986
1987 // Calculate offsets for String and Class classes since they are loaded and
1988 // can be used after this point.
1989 java_lang_String::compute_offsets();
1990 java_lang_Class::compute_offsets();
2006
2007 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK);
2008 InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
2009 InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK);
2010 InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL);
2011 InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM);
2012
2013 // JSR 292 classes
2014 WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass);
2015 WKID jsr292_group_end = WK_KLASS_ENUM_NAME(VolatileCallSite_klass);
2016 initialize_wk_klasses_until(jsr292_group_start, scan, CHECK);
2017 if (EnableInvokeDynamic) {
2018 initialize_wk_klasses_through(jsr292_group_end, scan, CHECK);
2019 } else {
2020 // Skip the JSR 292 classes, if not enabled.
2021 scan = WKID(jsr292_group_end + 1);
2022 }
2023
2024 initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK);
2025
2026 check_wk_pre_link_klasses();
2027
2028 _box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass);
2029 _box_klasses[T_CHAR] = WK_KLASS(Character_klass);
2030 _box_klasses[T_FLOAT] = WK_KLASS(Float_klass);
2031 _box_klasses[T_DOUBLE] = WK_KLASS(Double_klass);
2032 _box_klasses[T_BYTE] = WK_KLASS(Byte_klass);
2033 _box_klasses[T_SHORT] = WK_KLASS(Short_klass);
2034 _box_klasses[T_INT] = WK_KLASS(Integer_klass);
2035 _box_klasses[T_LONG] = WK_KLASS(Long_klass);
2036 //_box_klasses[T_OBJECT] = WK_KLASS(object_klass);
2037 //_box_klasses[T_ARRAY] = WK_KLASS(object_klass);
2038
2039 #ifdef KERNEL
2040 if (DownloadManager_klass() == NULL) {
2041 warning("Cannot find sun/jkernel/DownloadManager");
2042 }
2043 #endif // KERNEL
2044
2045 { // Compute whether we should use loadClass or loadClassInternal when loading classes.
2046 Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
2047 _has_loadClassInternal = (method != NULL);
|