1811 // and classname information is enough to determine a class's package |
1811 // and classname information is enough to determine a class's package |
1812 bool instanceKlass::is_same_class_package(oop class_loader1, symbolOop class_name1, |
1812 bool instanceKlass::is_same_class_package(oop class_loader1, symbolOop class_name1, |
1813 oop class_loader2, symbolOop class_name2) { |
1813 oop class_loader2, symbolOop class_name2) { |
1814 if (class_loader1 != class_loader2) { |
1814 if (class_loader1 != class_loader2) { |
1815 return false; |
1815 return false; |
|
1816 } else if (class_name1 == class_name2) { |
|
1817 return true; // skip painful bytewise comparison |
1816 } else { |
1818 } else { |
1817 ResourceMark rm; |
1819 ResourceMark rm; |
1818 |
1820 |
1819 // The symbolOop's are in UTF8 encoding. Since we only need to check explicitly |
1821 // The symbolOop's are in UTF8 encoding. Since we only need to check explicitly |
1820 // for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding. |
1822 // for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding. |
1857 return UTF8::equal(name1, length1, name2, length2); |
1859 return UTF8::equal(name1, length1, name2, length2); |
1858 } |
1860 } |
1859 } |
1861 } |
1860 } |
1862 } |
1861 |
1863 |
|
1864 /* defined for now in jvm.cpp, for historical reasons *-- |
|
1865 klassOop instanceKlass::compute_enclosing_class_impl(instanceKlassHandle self, |
|
1866 symbolOop& simple_name_result, TRAPS) { |
|
1867 ... |
|
1868 } |
|
1869 */ |
|
1870 |
|
1871 // tell if two classes have the same enclosing class (at package level) |
|
1872 bool instanceKlass::is_same_package_member_impl(instanceKlassHandle class1, |
|
1873 klassOop class2_oop, TRAPS) { |
|
1874 if (class2_oop == class1->as_klassOop()) return true; |
|
1875 if (!Klass::cast(class2_oop)->oop_is_instance()) return false; |
|
1876 instanceKlassHandle class2(THREAD, class2_oop); |
|
1877 |
|
1878 // must be in same package before we try anything else |
|
1879 if (!class1->is_same_class_package(class2->class_loader(), class2->name())) |
|
1880 return false; |
|
1881 |
|
1882 // As long as there is an outer1.getEnclosingClass, |
|
1883 // shift the search outward. |
|
1884 instanceKlassHandle outer1 = class1; |
|
1885 for (;;) { |
|
1886 // As we walk along, look for equalities between outer1 and class2. |
|
1887 // Eventually, the walks will terminate as outer1 stops |
|
1888 // at the top-level class around the original class. |
|
1889 symbolOop ignore_name; |
|
1890 klassOop next = outer1->compute_enclosing_class(ignore_name, CHECK_false); |
|
1891 if (next == NULL) break; |
|
1892 if (next == class2()) return true; |
|
1893 outer1 = instanceKlassHandle(THREAD, next); |
|
1894 } |
|
1895 |
|
1896 // Now do the same for class2. |
|
1897 instanceKlassHandle outer2 = class2; |
|
1898 for (;;) { |
|
1899 symbolOop ignore_name; |
|
1900 klassOop next = outer2->compute_enclosing_class(ignore_name, CHECK_false); |
|
1901 if (next == NULL) break; |
|
1902 // Might as well check the new outer against all available values. |
|
1903 if (next == class1()) return true; |
|
1904 if (next == outer1()) return true; |
|
1905 outer2 = instanceKlassHandle(THREAD, next); |
|
1906 } |
|
1907 |
|
1908 // If by this point we have not found an equality between the |
|
1909 // two classes, we know they are in separate package members. |
|
1910 return false; |
|
1911 } |
|
1912 |
1862 |
1913 |
1863 jint instanceKlass::compute_modifier_flags(TRAPS) const { |
1914 jint instanceKlass::compute_modifier_flags(TRAPS) const { |
1864 klassOop k = as_klassOop(); |
1915 klassOop k = as_klassOop(); |
1865 jint access = access_flags().as_int(); |
1916 jint access = access_flags().as_int(); |
1866 |
1917 |
2017 juint length = java_lang_String::length(obj); |
2070 juint length = java_lang_String::length(obj); |
2018 if (value != NULL && |
2071 if (value != NULL && |
2019 value->is_typeArray() && |
2072 value->is_typeArray() && |
2020 offset <= (juint) value->length() && |
2073 offset <= (juint) value->length() && |
2021 offset + length <= (juint) value->length()) { |
2074 offset + length <= (juint) value->length()) { |
2022 st->print("string: "); |
2075 st->print(BULLET"string: "); |
2023 Handle h_obj(obj); |
2076 Handle h_obj(obj); |
2024 java_lang_String::print(h_obj, st); |
2077 java_lang_String::print(h_obj, st); |
2025 st->cr(); |
2078 st->cr(); |
2026 if (!WizardMode) return; // that is enough |
2079 if (!WizardMode) return; // that is enough |
2027 } |
2080 } |
2028 } |
2081 } |
2029 |
2082 |
2030 st->print_cr("fields:"); |
2083 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj)); |
2031 FieldPrinter print_nonstatic_field(st, obj); |
2084 FieldPrinter print_nonstatic_field(st, obj); |
2032 do_nonstatic_fields(&print_nonstatic_field); |
2085 do_nonstatic_fields(&print_nonstatic_field); |
2033 |
2086 |
2034 if (as_klassOop() == SystemDictionary::class_klass()) { |
2087 if (as_klassOop() == SystemDictionary::class_klass()) { |
|
2088 st->print(BULLET"signature: "); |
|
2089 java_lang_Class::print_signature(obj, st); |
|
2090 st->cr(); |
2035 klassOop mirrored_klass = java_lang_Class::as_klassOop(obj); |
2091 klassOop mirrored_klass = java_lang_Class::as_klassOop(obj); |
2036 st->print(" - fake entry for mirror: "); |
2092 st->print(BULLET"fake entry for mirror: "); |
2037 mirrored_klass->print_value_on(st); |
2093 mirrored_klass->print_value_on(st); |
2038 st->cr(); |
2094 st->cr(); |
2039 st->print(" - fake entry resolved_constructor: "); |
2095 st->print(BULLET"fake entry resolved_constructor: "); |
2040 methodOop ctor = java_lang_Class::resolved_constructor(obj); |
2096 methodOop ctor = java_lang_Class::resolved_constructor(obj); |
2041 ctor->print_value_on(st); |
2097 ctor->print_value_on(st); |
2042 klassOop array_klass = java_lang_Class::array_klass(obj); |
2098 klassOop array_klass = java_lang_Class::array_klass(obj); |
2043 st->print(" - fake entry for array: "); |
2099 st->cr(); |
|
2100 st->print(BULLET"fake entry for array: "); |
2044 array_klass->print_value_on(st); |
2101 array_klass->print_value_on(st); |
2045 st->cr(); |
|
2046 st->cr(); |
2102 st->cr(); |
2047 } |
2103 } |
2048 } |
2104 } |
2049 |
2105 |
2050 void instanceKlass::oop_print_value_on(oop obj, outputStream* st) { |
2106 void instanceKlass::oop_print_value_on(oop obj, outputStream* st) { |
2051 st->print("a "); |
2107 st->print("a "); |
2052 name()->print_value_on(st); |
2108 name()->print_value_on(st); |
2053 obj->print_address_on(st); |
2109 obj->print_address_on(st); |
|
2110 if (as_klassOop() == SystemDictionary::string_klass() |
|
2111 && java_lang_String::value(obj) != NULL) { |
|
2112 ResourceMark rm; |
|
2113 int len = java_lang_String::length(obj); |
|
2114 int plen = (len < 24 ? len : 12); |
|
2115 char* str = java_lang_String::as_utf8_string(obj, 0, plen); |
|
2116 st->print(" = \"%s\"", str); |
|
2117 if (len > plen) |
|
2118 st->print("...[%d]", len); |
|
2119 } else if (as_klassOop() == SystemDictionary::class_klass()) { |
|
2120 klassOop k = java_lang_Class::as_klassOop(obj); |
|
2121 st->print(" = "); |
|
2122 if (k != NULL) { |
|
2123 k->print_value_on(st); |
|
2124 } else { |
|
2125 const char* tname = type2name(java_lang_Class::primitive_type(obj)); |
|
2126 st->print("%s", tname ? tname : "type?"); |
|
2127 } |
|
2128 } else if (java_lang_boxing_object::is_instance(obj)) { |
|
2129 st->print(" = "); |
|
2130 java_lang_boxing_object::print(obj, st); |
|
2131 } |
2054 } |
2132 } |
2055 |
2133 |
2056 #endif // ndef PRODUCT |
2134 #endif // ndef PRODUCT |
2057 |
2135 |
2058 const char* instanceKlass::internal_name() const { |
2136 const char* instanceKlass::internal_name() const { |