Mercurial > hg > truffle

comparison src/share/vm/classfile/javaClasses.cpp @ 2177:3582bf76420e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6990754: Use native memory and reference counting to implement SymbolTable Summary: move symbols from permgen into C heap and reference count them Reviewed-by: never, acorn, jmasa, stefank
author coleenp
date Thu, 27 Jan 2011 16:11:27 -0800
parents 017cd8bce8a8
children 72dee110246f
comparison
equal deleted inserted replaced
2176:27e4ea99855d 2177:3582bf76420e
34 #include "memory/universe.inline.hpp" 34 #include "memory/universe.inline.hpp"
35 #include "oops/instanceKlass.hpp" 35 #include "oops/instanceKlass.hpp"
36 #include "oops/klass.hpp" 36 #include "oops/klass.hpp"
37 #include "oops/klassOop.hpp" 37 #include "oops/klassOop.hpp"
38 #include "oops/methodOop.hpp" 38 #include "oops/methodOop.hpp"
39 #include "oops/symbolOop.hpp" 39 #include "oops/symbol.hpp"
40 #include "oops/typeArrayOop.hpp" 40 #include "oops/typeArrayOop.hpp"
41 #include "runtime/fieldDescriptor.hpp" 41 #include "runtime/fieldDescriptor.hpp"
42 #include "runtime/handles.inline.hpp" 42 #include "runtime/handles.inline.hpp"
43 #include "runtime/interfaceSupport.hpp" 43 #include "runtime/interfaceSupport.hpp"
44 #include "runtime/java.hpp" 44 #include "runtime/java.hpp"
55 #ifdef TARGET_OS_FAMILY_windows 55 #ifdef TARGET_OS_FAMILY_windows
56 # include "thread_windows.inline.hpp" 56 # include "thread_windows.inline.hpp"
57 #endif 57 #endif
58 58
59 static bool find_field(instanceKlass* ik, 59 static bool find_field(instanceKlass* ik,
60 symbolOop name_symbol, symbolOop signature_symbol, 60 Symbol* name_symbol, Symbol* signature_symbol,
61 fieldDescriptor* fd, 61 fieldDescriptor* fd,
62 bool allow_super = false) { 62 bool allow_super = false) {
63 if (allow_super) 63 if (allow_super)
64 return ik->find_field(name_symbol, signature_symbol, fd) != NULL; 64 return ik->find_field(name_symbol, signature_symbol, fd) != NULL;
65 else 65 else
67 } 67 }
68 68
69 // Helpful routine for computing field offsets at run time rather than hardcoding them 69 // Helpful routine for computing field offsets at run time rather than hardcoding them
70 static void 70 static void
71 compute_offset(int &dest_offset, 71 compute_offset(int &dest_offset,
72 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol, 72 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
73 bool allow_super = false) { 73 bool allow_super = false) {
74 fieldDescriptor fd; 74 fieldDescriptor fd;
75 instanceKlass* ik = instanceKlass::cast(klass_oop); 75 instanceKlass* ik = instanceKlass::cast(klass_oop);
76 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { 76 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
77 ResourceMark rm; 77 ResourceMark rm;
82 } 82 }
83 83
84 // Same as above but for "optional" offsets that might not be present in certain JDK versions 84 // Same as above but for "optional" offsets that might not be present in certain JDK versions
85 static void 85 static void
86 compute_optional_offset(int& dest_offset, 86 compute_optional_offset(int& dest_offset,
87 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol, 87 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
88 bool allow_super = false) { 88 bool allow_super = false) {
89 fieldDescriptor fd; 89 fieldDescriptor fd;
90 instanceKlass* ik = instanceKlass::cast(klass_oop); 90 instanceKlass* ik = instanceKlass::cast(klass_oop);
91 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { 91 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
92 dest_offset = fd.offset(); 92 dest_offset = fd.offset();
162 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) { 162 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {
163 Handle h_obj = create_from_str(utf8_str, CHECK_0); 163 Handle h_obj = create_from_str(utf8_str, CHECK_0);
164 return h_obj(); 164 return h_obj();
165 } 165 }
166 166
167 Handle java_lang_String::create_from_symbol(symbolHandle symbol, TRAPS) { 167 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
168 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); 168 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());
169 Handle h_obj = basic_create(length, false, CHECK_NH); 169 Handle h_obj = basic_create(length, false, CHECK_NH);
170 if (length > 0) { 170 if (length > 0) {
171 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); 171 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);
172 } 172 }
276 result[index] = value->char_at(index + offset); 276 result[index] = value->char_at(index + offset);
277 } 277 }
278 return result; 278 return result;
279 } 279 }
280 280
281 symbolHandle java_lang_String::as_symbol(Handle java_string, TRAPS) { 281 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
282 oop obj = java_string(); 282 oop obj = java_string();
283 typeArrayOop value = java_lang_String::value(obj); 283 typeArrayOop value = java_lang_String::value(obj);
284 int offset = java_lang_String::offset(obj); 284 int offset = java_lang_String::offset(obj);
285 int length = java_lang_String::length(obj); 285 int length = java_lang_String::length(obj);
286 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 286 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
287 symbolOop sym = SymbolTable::lookup_unicode(base, length, THREAD); 287 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
288 return symbolHandle(THREAD, sym); 288 return sym;
289 } 289 }
290 290
291 symbolOop java_lang_String::as_symbol_or_null(oop java_string) { 291 Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
292 typeArrayOop value = java_lang_String::value(java_string); 292 typeArrayOop value = java_lang_String::value(java_string);
293 int offset = java_lang_String::offset(java_string); 293 int offset = java_lang_String::offset(java_string);
294 int length = java_lang_String::length(java_string); 294 int length = java_lang_String::length(java_string);
295 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 295 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
296 return SymbolTable::probe_unicode(base, length); 296 return SymbolTable::probe_unicode(base, length);
435 } 435 }
436 436
437 437
438 void java_lang_Class::print_signature(oop java_class, outputStream* st) { 438 void java_lang_Class::print_signature(oop java_class, outputStream* st) {
439 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 439 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
440 symbolOop name = NULL; 440 Symbol* name = NULL;
441 bool is_instance = false; 441 bool is_instance = false;
442 if (is_primitive(java_class)) { 442 if (is_primitive(java_class)) {
443 name = vmSymbols::type_signature(primitive_type(java_class)); 443 name = vmSymbols::type_signature(primitive_type(java_class));
444 } else { 444 } else {
445 klassOop k = as_klassOop(java_class); 445 klassOop k = as_klassOop(java_class);
453 if (is_instance) st->print("L"); 453 if (is_instance) st->print("L");
454 st->write((char*) name->base(), (int) name->utf8_length()); 454 st->write((char*) name->base(), (int) name->utf8_length());
455 if (is_instance) st->print(";"); 455 if (is_instance) st->print(";");
456 } 456 }
457 457
458 symbolOop java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) { 458 Symbol* java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) {
459 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 459 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
460 symbolOop name = NULL; 460 Symbol* name;
461 if (is_primitive(java_class)) { 461 if (is_primitive(java_class)) {
462 return vmSymbols::type_signature(primitive_type(java_class)); 462 name = vmSymbols::type_signature(primitive_type(java_class));
463 // Because this can create a new symbol, the caller has to decrement
464 // the refcount, so make adjustment here and below for symbols returned
465 // that are not created or incremented due to a successful lookup.
466 name->increment_refcount();
463 } else { 467 } else {
464 klassOop k = as_klassOop(java_class); 468 klassOop k = as_klassOop(java_class);
465 if (!Klass::cast(k)->oop_is_instance()) { 469 if (!Klass::cast(k)->oop_is_instance()) {
466 return Klass::cast(k)->name(); 470 name = Klass::cast(k)->name();
471 name->increment_refcount();
467 } else { 472 } else {
468 ResourceMark rm; 473 ResourceMark rm;
469 const char* sigstr = Klass::cast(k)->signature_name(); 474 const char* sigstr = Klass::cast(k)->signature_name();
470 int siglen = (int) strlen(sigstr); 475 int siglen = (int) strlen(sigstr);
471 if (!intern_if_not_found) 476 if (!intern_if_not_found) {
472 return SymbolTable::probe(sigstr, siglen); 477 name = SymbolTable::probe(sigstr, siglen);
473 else 478 } else {
474 return oopFactory::new_symbol(sigstr, siglen, THREAD); 479 name = SymbolTable::new_symbol(sigstr, siglen, THREAD);
480 }
475 } 481 }
476 } 482 }
483 return name;
477 } 484 }
478 485
479 486
480 klassOop java_lang_Class::array_klass(oop java_class) { 487 klassOop java_lang_Class::array_klass(oop java_class) {
481 klassOop k = klassOop(java_class->obj_field(array_klass_offset)); 488 klassOop k = klassOop(java_class->obj_field(array_klass_offset));
1020 Handle arg (THREAD, oopFactory::new_charArray(str, THREAD)); 1027 Handle arg (THREAD, oopFactory::new_charArray(str, THREAD));
1021 if (!HAS_PENDING_EXCEPTION) { 1028 if (!HAS_PENDING_EXCEPTION) {
1022 JavaCalls::call_virtual(&result, 1029 JavaCalls::call_virtual(&result,
1023 stream, 1030 stream,
1024 KlassHandle(THREAD, stream->klass()), 1031 KlassHandle(THREAD, stream->klass()),
1025 vmSymbolHandles::println_name(), 1032 vmSymbols::println_name(),
1026 vmSymbolHandles::char_array_void_signature(), 1033 vmSymbols::char_array_void_signature(),
1027 arg, 1034 arg,
1028 THREAD); 1035 THREAD);
1029 } 1036 }
1030 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. 1037 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1031 if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION; 1038 if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;
1075 EXCEPTION_MARK; 1082 EXCEPTION_MARK;
1076 JavaValue result(T_OBJECT); 1083 JavaValue result(T_OBJECT);
1077 JavaCalls::call_virtual(&result, 1084 JavaCalls::call_virtual(&result,
1078 h_throwable, 1085 h_throwable,
1079 KlassHandle(THREAD, h_throwable->klass()), 1086 KlassHandle(THREAD, h_throwable->klass()),
1080 vmSymbolHandles::getCause_name(), 1087 vmSymbols::getCause_name(),
1081 vmSymbolHandles::void_throwable_signature(), 1088 vmSymbols::void_throwable_signature(),
1082 THREAD); 1089 THREAD);
1083 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. 1090 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1084 if (HAS_PENDING_EXCEPTION) { 1091 if (HAS_PENDING_EXCEPTION) {
1085 CLEAR_PENDING_EXCEPTION; 1092 CLEAR_PENDING_EXCEPTION;
1086 h_throwable = Handle(); 1093 h_throwable = Handle();
1514 java_lang_StackTraceElement::set_declaringClass(element(), classname); 1521 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1515 // Fill in method name 1522 // Fill in method name
1516 oop methodname = StringTable::intern(method->name(), CHECK_0); 1523 oop methodname = StringTable::intern(method->name(), CHECK_0);
1517 java_lang_StackTraceElement::set_methodName(element(), methodname); 1524 java_lang_StackTraceElement::set_methodName(element(), methodname);
1518 // Fill in source file name 1525 // Fill in source file name
1519 symbolOop source = instanceKlass::cast(method->method_holder())->source_file_name(); 1526 Symbol* source = instanceKlass::cast(method->method_holder())->source_file_name();
1520 oop filename = StringTable::intern(source, CHECK_0); 1527 oop filename = StringTable::intern(source, CHECK_0);
1521 java_lang_StackTraceElement::set_fileName(element(), filename); 1528 java_lang_StackTraceElement::set_fileName(element(), filename);
1522 // File in source line number 1529 // File in source line number
1523 int line_number; 1530 int line_number;
1524 if (method->is_native()) { 1531 if (method->is_native()) {
1730 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); 1737 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1731 } 1738 }
1732 1739
1733 Handle java_lang_reflect_Constructor::create(TRAPS) { 1740 Handle java_lang_reflect_Constructor::create(TRAPS) {
1734 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1741 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1735 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor(); 1742 Symbol* name = vmSymbols::java_lang_reflect_Constructor();
1736 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 1743 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1737 instanceKlassHandle klass (THREAD, k); 1744 instanceKlassHandle klass (THREAD, k);
1738 // Ensure it is initialized 1745 // Ensure it is initialized
1739 klass->initialize(CHECK_NH); 1746 klass->initialize(CHECK_NH);
1740 return klass->allocate_instance_handle(CHECK_NH); 1747 return klass->allocate_instance_handle(CHECK_NH);
1852 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 1859 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1853 } 1860 }
1854 1861
1855 Handle java_lang_reflect_Field::create(TRAPS) { 1862 Handle java_lang_reflect_Field::create(TRAPS) {
1856 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1863 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1857 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field(); 1864 Symbol* name = vmSymbols::java_lang_reflect_Field();
1858 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 1865 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1859 instanceKlassHandle klass (THREAD, k); 1866 instanceKlassHandle klass (THREAD, k);
1860 // Ensure it is initialized 1867 // Ensure it is initialized
1861 klass->initialize(CHECK_NH); 1868 klass->initialize(CHECK_NH);
1862 return klass->allocate_instance_handle(CHECK_NH); 1869 return klass->allocate_instance_handle(CHECK_NH);
2420 } 2427 }
2421 st->print(")"); 2428 st->print(")");
2422 java_lang_Class::print_signature(rtype(mt), st); 2429 java_lang_Class::print_signature(rtype(mt), st);
2423 } 2430 }
2424 2431
2425 symbolOop java_dyn_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) { 2432 Symbol* java_dyn_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) {
2426 ResourceMark rm; 2433 ResourceMark rm;
2427 stringStream buffer(128); 2434 stringStream buffer(128);
2428 print_signature(mt, &buffer); 2435 print_signature(mt, &buffer);
2429 const char* sigstr = buffer.base(); 2436 const char* sigstr = buffer.base();
2430 int siglen = (int) buffer.size(); 2437 int siglen = (int) buffer.size();
2431 if (!intern_if_not_found) 2438 Symbol *name;
2432 return SymbolTable::probe(sigstr, siglen); 2439 if (!intern_if_not_found) {
2433 else 2440 name = SymbolTable::probe(sigstr, siglen);
2434 return oopFactory::new_symbol(sigstr, siglen, THREAD); 2441 } else {
2442 name = SymbolTable::new_symbol(sigstr, siglen, THREAD);
2443 }
2444 return name;
2435 } 2445 }
2436 2446
2437 oop java_dyn_MethodType::rtype(oop mt) { 2447 oop java_dyn_MethodType::rtype(oop mt) {
2438 assert(is_instance(mt), "must be a MethodType"); 2448 assert(is_instance(mt), "must be a MethodType");
2439 return mt->obj_field(_rtype_offset); 2449 return mt->obj_field(_rtype_offset);
2906 // against changes in the class files 2916 // against changes in the class files
2907 2917
2908 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { 2918 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
2909 EXCEPTION_MARK; 2919 EXCEPTION_MARK;
2910 fieldDescriptor fd; 2920 fieldDescriptor fd;
2911 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); 2921 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
2912 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 2922 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
2913 instanceKlassHandle h_klass (THREAD, k); 2923 instanceKlassHandle h_klass (THREAD, k);
2914 //instanceKlassHandle h_klass(klass); 2924 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
2915 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); 2925 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
2916 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); 2926 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
2917 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2918 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name); 2927 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
2919 return false; 2928 return false;
2920 } 2929 }
2921 if (fd.is_static()) { 2930 if (fd.is_static()) {
2922 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name); 2931 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);
2933 2942
2934 2943
2935 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { 2944 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
2936 EXCEPTION_MARK; 2945 EXCEPTION_MARK;
2937 fieldDescriptor fd; 2946 fieldDescriptor fd;
2938 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); 2947 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
2939 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 2948 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
2940 instanceKlassHandle h_klass (THREAD, k); 2949 instanceKlassHandle h_klass (THREAD, k);
2941 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); 2950 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
2942 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); 2951 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
2943 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) { 2952 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
2944 tty->print_cr("Static field %s.%s not found", klass_name, field_name); 2953 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2945 return false; 2954 return false;
2946 } 2955 }
2947 if (!fd.is_static()) { 2956 if (!fd.is_static()) {
2948 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name); 2957 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
2958 2967
2959 2968
2960 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { 2969 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) {
2961 EXCEPTION_MARK; 2970 EXCEPTION_MARK;
2962 fieldDescriptor fd; 2971 fieldDescriptor fd;
2963 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); 2972 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
2964 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 2973 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
2965 instanceKlassHandle h_klass (THREAD, k); 2974 instanceKlassHandle h_klass (THREAD, k);
2966 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); 2975 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
2967 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); 2976 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
2968 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) { 2977 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
2969 tty->print_cr("Static field %s.%s not found", klass_name, field_name); 2978 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2970 return false; 2979 return false;
2971 } 2980 }
2972 if (!fd.is_static() || !fd.has_initial_value()) { 2981 if (!fd.is_static() || !fd.has_initial_value()) {
2973 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name); 2982 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name);