Mercurial > hg > truffle

comparison src/share/vm/oops/instanceKlass.cpp @ 665:c89f86385056

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6814659: separable cleanups and subroutines for 6655638 Summary: preparatory but separable changes for method handles Reviewed-by: kvn, never
author jrose
date Fri, 20 Mar 2009 23:19:36 -0700
parents 98cb887364d3
children d3676b4cb78c
comparison
equal deleted inserted replaced
647:bd441136a5ce 665:c89f86385056
1 /* 1 /*
2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. 2 * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
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
1994 // ----------------------------------------------------------------------------------------------------- 2045 // -----------------------------------------------------------------------------------------------------
1995 #ifndef PRODUCT 2046 #ifndef PRODUCT
1996 2047
1997 // Printing 2048 // Printing
1998 2049
2050 #define BULLET " - "
2051
1999 void FieldPrinter::do_field(fieldDescriptor* fd) { 2052 void FieldPrinter::do_field(fieldDescriptor* fd) {
2000 if (fd->is_static() == (_obj == NULL)) { 2053 _st->print(BULLET);
2001 _st->print(" - "); 2054 if (fd->is_static() || (_obj == NULL)) {
2002 fd->print_on(_st); 2055 fd->print_on(_st);
2003 _st->cr(); 2056 _st->cr();
2004 } else { 2057 } else {
2005 fd->print_on_for(_st, _obj); 2058 fd->print_on_for(_st, _obj);
2006 _st->cr(); 2059 _st->cr();
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 {