1 /* 2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 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 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/javaClasses.hpp" 27 #include "classfile/symbolTable.hpp" 28 #include "classfile/vmSymbols.hpp" 29 #include "code/debugInfo.hpp" 30 #include "code/pcDesc.hpp" 31 #include "interpreter/interpreter.hpp" 32 #include "memory/oopFactory.hpp" 33 #include "memory/resourceArea.hpp" 34 #include "memory/universe.inline.hpp" 35 #include "oops/instanceKlass.hpp" 36 #include "oops/instanceMirrorKlass.hpp" 37 #include "oops/klass.hpp" 38 #include "oops/klassOop.hpp" 39 #include "oops/methodOop.hpp" 40 #include "oops/symbol.hpp" 41 #include "oops/typeArrayOop.hpp" 42 #include "runtime/fieldDescriptor.hpp" 43 #include "runtime/handles.inline.hpp" 44 #include "runtime/interfaceSupport.hpp" 45 #include "runtime/java.hpp" 46 #include "runtime/javaCalls.hpp" 47 #include "runtime/safepoint.hpp" 48 #include "runtime/vframe.hpp" 49 #include "utilities/preserveException.hpp" 50 #ifdef TARGET_OS_FAMILY_linux 51 # include "thread_linux.inline.hpp" 52 #endif 53 #ifdef TARGET_OS_FAMILY_solaris 54 # include "thread_solaris.inline.hpp" 55 #endif 56 #ifdef TARGET_OS_FAMILY_windows 57 # include "thread_windows.inline.hpp" 58 #endif 59 60 static bool find_field(instanceKlass* ik, 61 Symbol* name_symbol, Symbol* signature_symbol, 62 fieldDescriptor* fd, 63 bool allow_super = false) { 64 if (allow_super) 65 return ik->find_field(name_symbol, signature_symbol, fd) != NULL; 66 else 67 return ik->find_local_field(name_symbol, signature_symbol, fd); 68 } 69 70 static bool find_hacked_field(instanceKlass* ik, 71 Symbol* name_symbol, Symbol* signature_symbol, 72 fieldDescriptor* fd, 73 bool allow_super = false) { 74 bool found = find_field(ik, name_symbol, signature_symbol, fd, allow_super); 75 if (!found && AllowTransitionalJSR292) { 76 Symbol* backup_sig = SystemDictionary::find_backup_signature(signature_symbol); 77 if (backup_sig != NULL) { 78 found = find_field(ik, name_symbol, backup_sig, fd, allow_super); 79 if (TraceMethodHandles) { 80 ResourceMark rm; 81 tty->print_cr("MethodHandles: %s.%s: backup for %s => %s%s", 82 ik->name()->as_C_string(), name_symbol->as_C_string(), 83 signature_symbol->as_C_string(), backup_sig->as_C_string(), 84 (found ? "" : " (NOT FOUND)")); 85 } 86 } 87 } 88 return found; 89 } 90 #define find_field find_hacked_field /* remove after AllowTransitionalJSR292 */ 91 92 // Helpful routine for computing field offsets at run time rather than hardcoding them 93 static void 94 compute_offset(int &dest_offset, 95 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol, 96 bool allow_super = false) { 97 fieldDescriptor fd; 98 instanceKlass* ik = instanceKlass::cast(klass_oop); 99 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { 100 ResourceMark rm; 101 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); 102 fatal("Invalid layout of preloaded class"); 103 } 104 dest_offset = fd.offset(); 105 } 106 107 // Same as above but for "optional" offsets that might not be present in certain JDK versions 108 static void 109 compute_optional_offset(int& dest_offset, 110 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol, 111 bool allow_super = false) { 112 fieldDescriptor fd; 113 instanceKlass* ik = instanceKlass::cast(klass_oop); 114 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { 115 dest_offset = fd.offset(); 116 } 117 } 118 119 120 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) { 121 // Create the String object first, so there's a chance that the String 122 // and the char array it points to end up in the same cache line. 123 oop obj; 124 if (tenured) { 125 obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_permanent_instance(CHECK_NH); 126 } else { 127 obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH); 128 } 129 130 // Create the char array. The String object must be handlized here 131 // because GC can happen as a result of the allocation attempt. 132 Handle h_obj(THREAD, obj); 133 typeArrayOop buffer; 134 if (tenured) { 135 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH); 136 } else { 137 buffer = oopFactory::new_charArray(length, CHECK_NH); 138 } 139 140 // Point the String at the char array 141 obj = h_obj(); 142 set_value(obj, buffer); 143 // No need to zero the offset, allocation zero'ed the entire String object 144 assert(offset(obj) == 0, "initial String offset should be zero"); 145 //set_offset(obj, 0); 146 set_count(obj, length); 147 148 return h_obj; 149 } 150 151 Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) { 152 Handle h_obj = basic_create(length, tenured, CHECK_NH); 153 typeArrayOop buffer = value(h_obj()); 154 for (int index = 0; index < length; index++) { 155 buffer->char_at_put(index, unicode[index]); 156 } 157 return h_obj; 158 } 159 160 Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { 161 return basic_create_from_unicode(unicode, length, false, CHECK_NH); 162 } 163 164 Handle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) { 165 return basic_create_from_unicode(unicode, length, JavaObjectsInPerm, CHECK_NH); 166 } 167 168 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) { 169 Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0); 170 return h_obj(); 171 } 172 173 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) { 174 if (utf8_str == NULL) { 175 return Handle(); 176 } 177 int length = UTF8::unicode_length(utf8_str); 178 Handle h_obj = basic_create(length, false, CHECK_NH); 179 if (length > 0) { 180 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length); 181 } 182 return h_obj; 183 } 184 185 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) { 186 Handle h_obj = create_from_str(utf8_str, CHECK_0); 187 return h_obj(); 188 } 189 190 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) { 191 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); 192 Handle h_obj = basic_create(length, false, CHECK_NH); 193 if (length > 0) { 194 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); 195 } 196 return h_obj; 197 } 198 199 // Converts a C string to a Java String based on current encoding 200 Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) { 201 assert(str != NULL, "bad arguments"); 202 203 typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *); 204 static to_java_string_fn_t _to_java_string_fn = NULL; 205 206 if (_to_java_string_fn == NULL) { 207 void *lib_handle = os::native_java_library(); 208 _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, os::dll_lookup(lib_handle, "NewStringPlatform")); 209 if (_to_java_string_fn == NULL) { 210 fatal("NewStringPlatform missing"); 211 } 212 } 213 214 jstring js = NULL; 215 { JavaThread* thread = (JavaThread*)THREAD; 216 assert(thread->is_Java_thread(), "must be java thread"); 217 HandleMark hm(thread); 218 ThreadToNativeFromVM ttn(thread); 219 js = (_to_java_string_fn)(thread->jni_environment(), str); 220 } 221 return Handle(THREAD, JNIHandles::resolve(js)); 222 } 223 224 // Converts a Java String to a native C string that can be used for 225 // native OS calls. 226 char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) { 227 228 typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*); 229 static to_platform_string_fn_t _to_platform_string_fn = NULL; 230 231 if (_to_platform_string_fn == NULL) { 232 void *lib_handle = os::native_java_library(); 233 _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, os::dll_lookup(lib_handle, "GetStringPlatformChars")); 234 if (_to_platform_string_fn == NULL) { 235 fatal("GetStringPlatformChars missing"); 236 } 237 } 238 239 char *native_platform_string; 240 { JavaThread* thread = (JavaThread*)THREAD; 241 assert(thread->is_Java_thread(), "must be java thread"); 242 JNIEnv *env = thread->jni_environment(); 243 jstring js = (jstring) JNIHandles::make_local(env, java_string()); 244 bool is_copy; 245 HandleMark hm(thread); 246 ThreadToNativeFromVM ttn(thread); 247 native_platform_string = (_to_platform_string_fn)(env, js, &is_copy); 248 assert(is_copy == JNI_TRUE, "is_copy value changed"); 249 JNIHandles::destroy_local(js); 250 } 251 return native_platform_string; 252 } 253 254 Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) { 255 oop obj = java_string(); 256 // Typical usage is to convert all '/' to '.' in string. 257 typeArrayOop value = java_lang_String::value(obj); 258 int offset = java_lang_String::offset(obj); 259 int length = java_lang_String::length(obj); 260 261 // First check if any from_char exist 262 int index; // Declared outside, used later 263 for (index = 0; index < length; index++) { 264 if (value->char_at(index + offset) == from_char) { 265 break; 266 } 267 } 268 if (index == length) { 269 // No from_char, so do not copy. 270 return java_string; 271 } 272 273 // Create new UNICODE buffer. Must handlize value because GC 274 // may happen during String and char array creation. 275 typeArrayHandle h_value(THREAD, value); 276 Handle string = basic_create(length, false, CHECK_NH); 277 278 typeArrayOop from_buffer = h_value(); 279 typeArrayOop to_buffer = java_lang_String::value(string()); 280 281 // Copy contents 282 for (index = 0; index < length; index++) { 283 jchar c = from_buffer->char_at(index + offset); 284 if (c == from_char) { 285 c = to_char; 286 } 287 to_buffer->char_at_put(index, c); 288 } 289 return string; 290 } 291 292 jchar* java_lang_String::as_unicode_string(oop java_string, int& length) { 293 typeArrayOop value = java_lang_String::value(java_string); 294 int offset = java_lang_String::offset(java_string); 295 length = java_lang_String::length(java_string); 296 297 jchar* result = NEW_RESOURCE_ARRAY(jchar, length); 298 for (int index = 0; index < length; index++) { 299 result[index] = value->char_at(index + offset); 300 } 301 return result; 302 } 303 304 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) { 305 oop obj = java_string(); 306 typeArrayOop value = java_lang_String::value(obj); 307 int offset = java_lang_String::offset(obj); 308 int length = java_lang_String::length(obj); 309 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 310 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD); 311 return sym; 312 } 313 314 Symbol* java_lang_String::as_symbol_or_null(oop java_string) { 315 typeArrayOop value = java_lang_String::value(java_string); 316 int offset = java_lang_String::offset(java_string); 317 int length = java_lang_String::length(java_string); 318 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 319 return SymbolTable::probe_unicode(base, length); 320 } 321 322 323 int java_lang_String::utf8_length(oop java_string) { 324 typeArrayOop value = java_lang_String::value(java_string); 325 int offset = java_lang_String::offset(java_string); 326 int length = java_lang_String::length(java_string); 327 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); 328 return UNICODE::utf8_length(position, length); 329 } 330 331 char* java_lang_String::as_utf8_string(oop java_string) { 332 typeArrayOop value = java_lang_String::value(java_string); 333 int offset = java_lang_String::offset(java_string); 334 int length = java_lang_String::length(java_string); 335 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); 336 return UNICODE::as_utf8(position, length); 337 } 338 339 char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) { 340 typeArrayOop value = java_lang_String::value(java_string); 341 int offset = java_lang_String::offset(java_string); 342 int length = java_lang_String::length(java_string); 343 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); 344 return UNICODE::as_utf8(position, length, buf, buflen); 345 } 346 347 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) { 348 typeArrayOop value = java_lang_String::value(java_string); 349 int offset = java_lang_String::offset(java_string); 350 int length = java_lang_String::length(java_string); 351 assert(start + len <= length, "just checking"); 352 jchar* position = value->char_at_addr(offset + start); 353 return UNICODE::as_utf8(position, len); 354 } 355 356 bool java_lang_String::equals(oop java_string, jchar* chars, int len) { 357 assert(SharedSkipVerify || 358 java_string->klass() == SystemDictionary::String_klass(), 359 "must be java_string"); 360 typeArrayOop value = java_lang_String::value(java_string); 361 int offset = java_lang_String::offset(java_string); 362 int length = java_lang_String::length(java_string); 363 if (length != len) { 364 return false; 365 } 366 for (int i = 0; i < len; i++) { 367 if (value->char_at(i + offset) != chars[i]) { 368 return false; 369 } 370 } 371 return true; 372 } 373 374 void java_lang_String::print(Handle java_string, outputStream* st) { 375 oop obj = java_string(); 376 assert(obj->klass() == SystemDictionary::String_klass(), "must be java_string"); 377 typeArrayOop value = java_lang_String::value(obj); 378 int offset = java_lang_String::offset(obj); 379 int length = java_lang_String::length(obj); 380 381 int end = MIN2(length, 100); 382 if (value == NULL) { 383 // This can happen if, e.g., printing a String 384 // object before its initializer has been called 385 st->print_cr("NULL"); 386 } else { 387 st->print("\""); 388 for (int index = 0; index < length; index++) { 389 st->print("%c", value->char_at(index + offset)); 390 } 391 st->print("\""); 392 } 393 } 394 395 static void initialize_static_field(fieldDescriptor* fd, TRAPS) { 396 Handle mirror (THREAD, fd->field_holder()->java_mirror()); 397 assert(mirror.not_null() && fd->is_static(), "just checking"); 398 if (fd->has_initial_value()) { 399 BasicType t = fd->field_type(); 400 switch (t) { 401 case T_BYTE: 402 mirror()->byte_field_put(fd->offset(), fd->int_initial_value()); 403 break; 404 case T_BOOLEAN: 405 mirror()->bool_field_put(fd->offset(), fd->int_initial_value()); 406 break; 407 case T_CHAR: 408 mirror()->char_field_put(fd->offset(), fd->int_initial_value()); 409 break; 410 case T_SHORT: 411 mirror()->short_field_put(fd->offset(), fd->int_initial_value()); 412 break; 413 case T_INT: 414 mirror()->int_field_put(fd->offset(), fd->int_initial_value()); 415 break; 416 case T_FLOAT: 417 mirror()->float_field_put(fd->offset(), fd->float_initial_value()); 418 break; 419 case T_DOUBLE: 420 mirror()->double_field_put(fd->offset(), fd->double_initial_value()); 421 break; 422 case T_LONG: 423 mirror()->long_field_put(fd->offset(), fd->long_initial_value()); 424 break; 425 case T_OBJECT: 426 { 427 #ifdef ASSERT 428 TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK); 429 assert(fd->signature() == sym, "just checking"); 430 #endif 431 oop string = fd->string_initial_value(CHECK); 432 mirror()->obj_field_put(fd->offset(), string); 433 } 434 break; 435 default: 436 THROW_MSG(vmSymbols::java_lang_ClassFormatError(), 437 "Illegal ConstantValue attribute in class file"); 438 } 439 } 440 } 441 442 443 // During bootstrap, java.lang.Class wasn't loaded so static field 444 // offsets were computed without the size added it. Go back and 445 // update all the static field offsets to included the size. 446 static void fixup_static_field(fieldDescriptor* fd, TRAPS) { 447 if (fd->is_static()) { 448 int real_offset = fd->offset() + instanceMirrorKlass::offset_of_static_fields(); 449 typeArrayOop fields = instanceKlass::cast(fd->field_holder())->fields(); 450 fields->short_at_put(fd->index() + instanceKlass::low_offset, extract_low_short_from_int(real_offset)); 451 fields->short_at_put(fd->index() + instanceKlass::high_offset, extract_high_short_from_int(real_offset)); 452 } 453 } 454 455 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) { 456 assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); 457 458 if (k->oop_is_instance()) { 459 // Fixup the offsets 460 instanceKlass::cast(k())->do_local_static_fields(&fixup_static_field, CHECK); 461 } 462 create_mirror(k, CHECK); 463 } 464 465 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) { 466 assert(k->java_mirror() == NULL, "should only assign mirror once"); 467 // Use this moment of initialization to cache modifier_flags also, 468 // to support Class.getModifiers(). Instance classes recalculate 469 // the cached flags after the class file is parsed, but before the 470 // class is put into the system dictionary. 471 int computed_modifiers = k->compute_modifier_flags(CHECK_0); 472 k->set_modifier_flags(computed_modifiers); 473 if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) { 474 // Allocate mirror (java.lang.Class instance) 475 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); 476 // Setup indirections 477 mirror->obj_field_put(klass_offset, k()); 478 k->set_java_mirror(mirror()); 479 480 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass()); 481 java_lang_Class::set_oop_size(mirror(), mk->instance_size(k)); 482 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror())); 483 484 // It might also have a component mirror. This mirror must already exist. 485 if (k->oop_is_javaArray()) { 486 Handle comp_mirror; 487 if (k->oop_is_typeArray()) { 488 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type(); 489 comp_mirror = Universe::java_mirror(type); 490 assert(comp_mirror.not_null(), "must have primitive mirror"); 491 } else if (k->oop_is_objArray()) { 492 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass(); 493 if (element_klass != NULL 494 && (Klass::cast(element_klass)->oop_is_instance() || 495 Klass::cast(element_klass)->oop_is_javaArray())) { 496 comp_mirror = Klass::cast(element_klass)->java_mirror(); 497 assert(comp_mirror.not_null(), "must have element mirror"); 498 } 499 // else some object array internal to the VM, like systemObjArrayKlassObj 500 } 501 if (comp_mirror.not_null()) { 502 // Two-way link between the array klass and its component mirror: 503 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror()); 504 set_array_klass(comp_mirror(), k->as_klassOop()); 505 } 506 } else if (k->oop_is_instance()) { 507 // Initialize static fields 508 instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL); 509 } 510 return mirror(); 511 } else { 512 return NULL; 513 } 514 } 515 516 517 518 int java_lang_Class::oop_size(oop java_class) { 519 assert(oop_size_offset != 0, "must be set"); 520 return java_class->int_field(oop_size_offset); 521 } 522 void java_lang_Class::set_oop_size(oop java_class, int size) { 523 assert(oop_size_offset != 0, "must be set"); 524 java_class->int_field_put(oop_size_offset, size); 525 } 526 int java_lang_Class::static_oop_field_count(oop java_class) { 527 assert(static_oop_field_count_offset != 0, "must be set"); 528 return java_class->int_field(static_oop_field_count_offset); 529 } 530 void java_lang_Class::set_static_oop_field_count(oop java_class, int size) { 531 assert(static_oop_field_count_offset != 0, "must be set"); 532 java_class->int_field_put(static_oop_field_count_offset, size); 533 } 534 535 536 537 538 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { 539 // This should be improved by adding a field at the Java level or by 540 // introducing a new VM klass (see comment in ClassFileParser) 541 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance((oop)NULL, CHECK_0); 542 if (type != T_VOID) { 543 klassOop aklass = Universe::typeArrayKlassObj(type); 544 assert(aklass != NULL, "correct bootstrap"); 545 set_array_klass(java_class, aklass); 546 } 547 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass()); 548 java_lang_Class::set_oop_size(java_class, mk->instance_size(oop(NULL))); 549 java_lang_Class::set_static_oop_field_count(java_class, 0); 550 return java_class; 551 } 552 553 554 klassOop java_lang_Class::as_klassOop(oop java_class) { 555 //%note memory_2 556 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 557 klassOop k = klassOop(java_class->obj_field(klass_offset)); 558 assert(k == NULL || k->is_klass(), "type check"); 559 return k; 560 } 561 562 563 void java_lang_Class::print_signature(oop java_class, outputStream* st) { 564 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 565 Symbol* name = NULL; 566 bool is_instance = false; 567 if (is_primitive(java_class)) { 568 name = vmSymbols::type_signature(primitive_type(java_class)); 569 } else { 570 klassOop k = as_klassOop(java_class); 571 is_instance = Klass::cast(k)->oop_is_instance(); 572 name = Klass::cast(k)->name(); 573 } 574 if (name == NULL) { 575 st->print("<null>"); 576 return; 577 } 578 if (is_instance) st->print("L"); 579 st->write((char*) name->base(), (int) name->utf8_length()); 580 if (is_instance) st->print(";"); 581 } 582 583 Symbol* java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) { 584 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 585 Symbol* name; 586 if (is_primitive(java_class)) { 587 name = vmSymbols::type_signature(primitive_type(java_class)); 588 // Because this can create a new symbol, the caller has to decrement 589 // the refcount, so make adjustment here and below for symbols returned 590 // that are not created or incremented due to a successful lookup. 591 name->increment_refcount(); 592 } else { 593 klassOop k = as_klassOop(java_class); 594 if (!Klass::cast(k)->oop_is_instance()) { 595 name = Klass::cast(k)->name(); 596 name->increment_refcount(); 597 } else { 598 ResourceMark rm; 599 const char* sigstr = Klass::cast(k)->signature_name(); 600 int siglen = (int) strlen(sigstr); 601 if (!intern_if_not_found) { 602 name = SymbolTable::probe(sigstr, siglen); 603 } else { 604 name = SymbolTable::new_symbol(sigstr, siglen, THREAD); 605 } 606 } 607 } 608 return name; 609 } 610 611 612 klassOop java_lang_Class::array_klass(oop java_class) { 613 klassOop k = klassOop(java_class->obj_field(array_klass_offset)); 614 assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass"); 615 return k; 616 } 617 618 619 void java_lang_Class::set_array_klass(oop java_class, klassOop klass) { 620 assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass"); 621 java_class->obj_field_put(array_klass_offset, klass); 622 } 623 624 625 methodOop java_lang_Class::resolved_constructor(oop java_class) { 626 oop constructor = java_class->obj_field(resolved_constructor_offset); 627 assert(constructor == NULL || constructor->is_method(), "should be method"); 628 return methodOop(constructor); 629 } 630 631 632 void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) { 633 assert(constructor->is_method(), "should be method"); 634 java_class->obj_field_put(resolved_constructor_offset, constructor); 635 } 636 637 638 bool java_lang_Class::is_primitive(oop java_class) { 639 // should assert: 640 //assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 641 klassOop k = klassOop(java_class->obj_field(klass_offset)); 642 return k == NULL; 643 } 644 645 646 BasicType java_lang_Class::primitive_type(oop java_class) { 647 assert(java_lang_Class::is_primitive(java_class), "just checking"); 648 klassOop ak = klassOop(java_class->obj_field(array_klass_offset)); 649 BasicType type = T_VOID; 650 if (ak != NULL) { 651 // Note: create_basic_type_mirror above initializes ak to a non-null value. 652 type = arrayKlass::cast(ak)->element_type(); 653 } else { 654 assert(java_class == Universe::void_mirror(), "only valid non-array primitive"); 655 } 656 assert(Universe::java_mirror(type) == java_class, "must be consistent"); 657 return type; 658 } 659 660 BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) { 661 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 662 if (is_primitive(java_class)) { 663 if (reference_klass != NULL) 664 (*reference_klass) = NULL; 665 return primitive_type(java_class); 666 } else { 667 if (reference_klass != NULL) 668 (*reference_klass) = as_klassOop(java_class); 669 return T_OBJECT; 670 } 671 } 672 673 674 oop java_lang_Class::primitive_mirror(BasicType t) { 675 oop mirror = Universe::java_mirror(t); 676 assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class"); 677 assert(java_lang_Class::is_primitive(mirror), "must be primitive"); 678 return mirror; 679 } 680 681 bool java_lang_Class::offsets_computed = false; 682 int java_lang_Class::classRedefinedCount_offset = -1; 683 int java_lang_Class::parallelCapable_offset = -1; 684 685 void java_lang_Class::compute_offsets() { 686 assert(!offsets_computed, "offsets should be initialized only once"); 687 offsets_computed = true; 688 689 klassOop k = SystemDictionary::Class_klass(); 690 // The classRedefinedCount field is only present starting in 1.5, 691 // so don't go fatal. 692 compute_optional_offset(classRedefinedCount_offset, 693 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); 694 695 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7, 696 klassOop k1 = SystemDictionary::ClassLoader_klass(); 697 compute_optional_offset(parallelCapable_offset, 698 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature()); 699 } 700 701 // For class loader classes, parallelCapable defined 702 // based on non-null field 703 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it 704 bool java_lang_Class::parallelCapable(oop class_loader) { 705 if (!JDK_Version::is_gte_jdk17x_version() 706 || parallelCapable_offset == -1) { 707 // Default for backward compatibility is false 708 return false; 709 } 710 return (class_loader->obj_field(parallelCapable_offset) != NULL); 711 } 712 713 int java_lang_Class::classRedefinedCount(oop the_class_mirror) { 714 if (!JDK_Version::is_gte_jdk15x_version() 715 || classRedefinedCount_offset == -1) { 716 // The classRedefinedCount field is only present starting in 1.5. 717 // If we don't have an offset for it then just return -1 as a marker. 718 return -1; 719 } 720 721 return the_class_mirror->int_field(classRedefinedCount_offset); 722 } 723 724 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) { 725 if (!JDK_Version::is_gte_jdk15x_version() 726 || classRedefinedCount_offset == -1) { 727 // The classRedefinedCount field is only present starting in 1.5. 728 // If we don't have an offset for it then nothing to set. 729 return; 730 } 731 732 the_class_mirror->int_field_put(classRedefinedCount_offset, value); 733 } 734 735 736 // Note: JDK1.1 and before had a privateInfo_offset field which was used for the 737 // platform thread structure, and a eetop offset which was used for thread 738 // local storage (and unused by the HotSpot VM). In JDK1.2 the two structures 739 // merged, so in the HotSpot VM we just use the eetop field for the thread 740 // instead of the privateInfo_offset. 741 // 742 // Note: The stackSize field is only present starting in 1.4. 743 744 int java_lang_Thread::_name_offset = 0; 745 int java_lang_Thread::_group_offset = 0; 746 int java_lang_Thread::_contextClassLoader_offset = 0; 747 int java_lang_Thread::_inheritedAccessControlContext_offset = 0; 748 int java_lang_Thread::_priority_offset = 0; 749 int java_lang_Thread::_eetop_offset = 0; 750 int java_lang_Thread::_daemon_offset = 0; 751 int java_lang_Thread::_stillborn_offset = 0; 752 int java_lang_Thread::_stackSize_offset = 0; 753 int java_lang_Thread::_tid_offset = 0; 754 int java_lang_Thread::_thread_status_offset = 0; 755 int java_lang_Thread::_park_blocker_offset = 0; 756 int java_lang_Thread::_park_event_offset = 0 ; 757 758 759 void java_lang_Thread::compute_offsets() { 760 assert(_group_offset == 0, "offsets should be initialized only once"); 761 762 klassOop k = SystemDictionary::Thread_klass(); 763 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); 764 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); 765 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); 766 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); 767 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); 768 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); 769 compute_offset(_eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature()); 770 compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature()); 771 // The stackSize field is only present starting in 1.4, so don't go fatal. 772 compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature()); 773 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal. 774 compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature()); 775 compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature()); 776 // The parkBlocker field is only present starting in 1.6, so don't go fatal. 777 compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature()); 778 compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(), 779 vmSymbols::long_signature()); 780 } 781 782 783 JavaThread* java_lang_Thread::thread(oop java_thread) { 784 return (JavaThread*)java_thread->address_field(_eetop_offset); 785 } 786 787 788 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) { 789 java_thread->address_field_put(_eetop_offset, (address)thread); 790 } 791 792 793 typeArrayOop java_lang_Thread::name(oop java_thread) { 794 oop name = java_thread->obj_field(_name_offset); 795 assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking"); 796 return typeArrayOop(name); 797 } 798 799 800 void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) { 801 assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL"); 802 java_thread->obj_field_put(_name_offset, name); 803 } 804 805 806 ThreadPriority java_lang_Thread::priority(oop java_thread) { 807 return (ThreadPriority)java_thread->int_field(_priority_offset); 808 } 809 810 811 void java_lang_Thread::set_priority(oop java_thread, ThreadPriority priority) { 812 java_thread->int_field_put(_priority_offset, priority); 813 } 814 815 816 oop java_lang_Thread::threadGroup(oop java_thread) { 817 return java_thread->obj_field(_group_offset); 818 } 819 820 821 bool java_lang_Thread::is_stillborn(oop java_thread) { 822 return java_thread->bool_field(_stillborn_offset) != 0; 823 } 824 825 826 // We never have reason to turn the stillborn bit off 827 void java_lang_Thread::set_stillborn(oop java_thread) { 828 java_thread->bool_field_put(_stillborn_offset, true); 829 } 830 831 832 bool java_lang_Thread::is_alive(oop java_thread) { 833 JavaThread* thr = java_lang_Thread::thread(java_thread); 834 return (thr != NULL); 835 } 836 837 838 bool java_lang_Thread::is_daemon(oop java_thread) { 839 return java_thread->bool_field(_daemon_offset) != 0; 840 } 841 842 843 void java_lang_Thread::set_daemon(oop java_thread) { 844 java_thread->bool_field_put(_daemon_offset, true); 845 } 846 847 oop java_lang_Thread::context_class_loader(oop java_thread) { 848 return java_thread->obj_field(_contextClassLoader_offset); 849 } 850 851 oop java_lang_Thread::inherited_access_control_context(oop java_thread) { 852 return java_thread->obj_field(_inheritedAccessControlContext_offset); 853 } 854 855 856 jlong java_lang_Thread::stackSize(oop java_thread) { 857 // The stackSize field is only present starting in 1.4 858 if (_stackSize_offset > 0) { 859 assert(JDK_Version::is_gte_jdk14x_version(), "sanity check"); 860 return java_thread->long_field(_stackSize_offset); 861 } else { 862 return 0; 863 } 864 } 865 866 // Write the thread status value to threadStatus field in java.lang.Thread java class. 867 void java_lang_Thread::set_thread_status(oop java_thread, 868 java_lang_Thread::ThreadStatus status) { 869 assert(JavaThread::current()->thread_state() == _thread_in_vm, "Java Thread is not running in vm"); 870 // The threadStatus is only present starting in 1.5 871 if (_thread_status_offset > 0) { 872 java_thread->int_field_put(_thread_status_offset, status); 873 } 874 } 875 876 // Read thread status value from threadStatus field in java.lang.Thread java class. 877 java_lang_Thread::ThreadStatus java_lang_Thread::get_thread_status(oop java_thread) { 878 assert(Thread::current()->is_VM_thread() || 879 JavaThread::current()->thread_state() == _thread_in_vm, 880 "Java Thread is not running in vm"); 881 // The threadStatus is only present starting in 1.5 882 if (_thread_status_offset > 0) { 883 return (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset); 884 } else { 885 // All we can easily figure out is if it is alive, but that is 886 // enough info for a valid unknown status. 887 // These aren't restricted to valid set ThreadStatus values, so 888 // use JVMTI values and cast. 889 JavaThread* thr = java_lang_Thread::thread(java_thread); 890 if (thr == NULL) { 891 // the thread hasn't run yet or is in the process of exiting 892 return NEW; 893 } 894 return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE; 895 } 896 } 897 898 899 jlong java_lang_Thread::thread_id(oop java_thread) { 900 // The thread ID field is only present starting in 1.5 901 if (_tid_offset > 0) { 902 return java_thread->long_field(_tid_offset); 903 } else { 904 return 0; 905 } 906 } 907 908 oop java_lang_Thread::park_blocker(oop java_thread) { 909 assert(JDK_Version::current().supports_thread_park_blocker() && 910 _park_blocker_offset != 0, "Must support parkBlocker field"); 911 912 if (_park_blocker_offset > 0) { 913 return java_thread->obj_field(_park_blocker_offset); 914 } 915 916 return NULL; 917 } 918 919 jlong java_lang_Thread::park_event(oop java_thread) { 920 if (_park_event_offset > 0) { 921 return java_thread->long_field(_park_event_offset); 922 } 923 return 0; 924 } 925 926 bool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) { 927 if (_park_event_offset > 0) { 928 java_thread->long_field_put(_park_event_offset, ptr); 929 return true; 930 } 931 return false; 932 } 933 934 935 const char* java_lang_Thread::thread_status_name(oop java_thread) { 936 assert(JDK_Version::is_gte_jdk15x_version() && _thread_status_offset != 0, "Must have thread status"); 937 ThreadStatus status = (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset); 938 switch (status) { 939 case NEW : return "NEW"; 940 case RUNNABLE : return "RUNNABLE"; 941 case SLEEPING : return "TIMED_WAITING (sleeping)"; 942 case IN_OBJECT_WAIT : return "WAITING (on object monitor)"; 943 case IN_OBJECT_WAIT_TIMED : return "TIMED_WAITING (on object monitor)"; 944 case PARKED : return "WAITING (parking)"; 945 case PARKED_TIMED : return "TIMED_WAITING (parking)"; 946 case BLOCKED_ON_MONITOR_ENTER : return "BLOCKED (on object monitor)"; 947 case TERMINATED : return "TERMINATED"; 948 default : return "UNKNOWN"; 949 }; 950 } 951 int java_lang_ThreadGroup::_parent_offset = 0; 952 int java_lang_ThreadGroup::_name_offset = 0; 953 int java_lang_ThreadGroup::_threads_offset = 0; 954 int java_lang_ThreadGroup::_groups_offset = 0; 955 int java_lang_ThreadGroup::_maxPriority_offset = 0; 956 int java_lang_ThreadGroup::_destroyed_offset = 0; 957 int java_lang_ThreadGroup::_daemon_offset = 0; 958 int java_lang_ThreadGroup::_vmAllowSuspension_offset = 0; 959 int java_lang_ThreadGroup::_nthreads_offset = 0; 960 int java_lang_ThreadGroup::_ngroups_offset = 0; 961 962 oop java_lang_ThreadGroup::parent(oop java_thread_group) { 963 assert(java_thread_group->is_oop(), "thread group must be oop"); 964 return java_thread_group->obj_field(_parent_offset); 965 } 966 967 // ("name as oop" accessor is not necessary) 968 969 typeArrayOop java_lang_ThreadGroup::name(oop java_thread_group) { 970 oop name = java_thread_group->obj_field(_name_offset); 971 // ThreadGroup.name can be null 972 return name == NULL ? (typeArrayOop)NULL : java_lang_String::value(name); 973 } 974 975 int java_lang_ThreadGroup::nthreads(oop java_thread_group) { 976 assert(java_thread_group->is_oop(), "thread group must be oop"); 977 return java_thread_group->int_field(_nthreads_offset); 978 } 979 980 objArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) { 981 oop threads = java_thread_group->obj_field(_threads_offset); 982 assert(threads != NULL, "threadgroups should have threads"); 983 assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code 984 return objArrayOop(threads); 985 } 986 987 int java_lang_ThreadGroup::ngroups(oop java_thread_group) { 988 assert(java_thread_group->is_oop(), "thread group must be oop"); 989 return java_thread_group->int_field(_ngroups_offset); 990 } 991 992 objArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) { 993 oop groups = java_thread_group->obj_field(_groups_offset); 994 assert(groups == NULL || groups->is_objArray(), "just checking"); // Todo: Add better type checking code 995 return objArrayOop(groups); 996 } 997 998 ThreadPriority java_lang_ThreadGroup::maxPriority(oop java_thread_group) { 999 assert(java_thread_group->is_oop(), "thread group must be oop"); 1000 return (ThreadPriority) java_thread_group->int_field(_maxPriority_offset); 1001 } 1002 1003 bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) { 1004 assert(java_thread_group->is_oop(), "thread group must be oop"); 1005 return java_thread_group->bool_field(_destroyed_offset) != 0; 1006 } 1007 1008 bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) { 1009 assert(java_thread_group->is_oop(), "thread group must be oop"); 1010 return java_thread_group->bool_field(_daemon_offset) != 0; 1011 } 1012 1013 bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) { 1014 assert(java_thread_group->is_oop(), "thread group must be oop"); 1015 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0; 1016 } 1017 1018 void java_lang_ThreadGroup::compute_offsets() { 1019 assert(_parent_offset == 0, "offsets should be initialized only once"); 1020 1021 klassOop k = SystemDictionary::ThreadGroup_klass(); 1022 1023 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); 1024 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 1025 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); 1026 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); 1027 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature()); 1028 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature()); 1029 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); 1030 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature()); 1031 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); 1032 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); 1033 } 1034 1035 oop java_lang_Throwable::backtrace(oop throwable) { 1036 return throwable->obj_field_acquire(backtrace_offset); 1037 } 1038 1039 1040 void java_lang_Throwable::set_backtrace(oop throwable, oop value) { 1041 throwable->release_obj_field_put(backtrace_offset, value); 1042 } 1043 1044 1045 oop java_lang_Throwable::message(oop throwable) { 1046 return throwable->obj_field(detailMessage_offset); 1047 } 1048 1049 1050 oop java_lang_Throwable::message(Handle throwable) { 1051 return throwable->obj_field(detailMessage_offset); 1052 } 1053 1054 1055 void java_lang_Throwable::set_message(oop throwable, oop value) { 1056 throwable->obj_field_put(detailMessage_offset, value); 1057 } 1058 1059 1060 void java_lang_Throwable::clear_stacktrace(oop throwable) { 1061 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); 1062 throwable->obj_field_put(stackTrace_offset, NULL); 1063 } 1064 1065 1066 void java_lang_Throwable::print(oop throwable, outputStream* st) { 1067 ResourceMark rm; 1068 klassOop k = throwable->klass(); 1069 assert(k != NULL, "just checking"); 1070 st->print("%s", instanceKlass::cast(k)->external_name()); 1071 oop msg = message(throwable); 1072 if (msg != NULL) { 1073 st->print(": %s", java_lang_String::as_utf8_string(msg)); 1074 } 1075 } 1076 1077 1078 void java_lang_Throwable::print(Handle throwable, outputStream* st) { 1079 ResourceMark rm; 1080 klassOop k = throwable->klass(); 1081 assert(k != NULL, "just checking"); 1082 st->print("%s", instanceKlass::cast(k)->external_name()); 1083 oop msg = message(throwable); 1084 if (msg != NULL) { 1085 st->print(": %s", java_lang_String::as_utf8_string(msg)); 1086 } 1087 } 1088 1089 // Print stack trace element to resource allocated buffer 1090 char* java_lang_Throwable::print_stack_element_to_buffer(methodOop method, int bci) { 1091 // Get strings and string lengths 1092 instanceKlass* klass = instanceKlass::cast(method->method_holder()); 1093 const char* klass_name = klass->external_name(); 1094 int buf_len = (int)strlen(klass_name); 1095 char* source_file_name; 1096 if (klass->source_file_name() == NULL) { 1097 source_file_name = NULL; 1098 } else { 1099 source_file_name = klass->source_file_name()->as_C_string(); 1100 buf_len += (int)strlen(source_file_name); 1101 } 1102 char* method_name = method->name()->as_C_string(); 1103 buf_len += (int)strlen(method_name); 1104 1105 // Allocate temporary buffer with extra space for formatting and line number 1106 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64); 1107 1108 // Print stack trace line in buffer 1109 sprintf(buf, "\tat %s.%s", klass_name, method_name); 1110 if (method->is_native()) { 1111 strcat(buf, "(Native Method)"); 1112 } else { 1113 int line_number = method->line_number_from_bci(bci); 1114 if (source_file_name != NULL && (line_number != -1)) { 1115 // Sourcename and linenumber 1116 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number); 1117 } else if (source_file_name != NULL) { 1118 // Just sourcename 1119 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name); 1120 } else { 1121 // Neither soucename and linenumber 1122 sprintf(buf + (int)strlen(buf), "(Unknown Source)"); 1123 } 1124 nmethod* nm = method->code(); 1125 if (WizardMode && nm != NULL) { 1126 sprintf(buf + (int)strlen(buf), "(nmethod " PTR_FORMAT ")", (intptr_t)nm); 1127 } 1128 } 1129 1130 return buf; 1131 } 1132 1133 1134 void java_lang_Throwable::print_stack_element(Handle stream, methodOop method, int bci) { 1135 ResourceMark rm; 1136 char* buf = print_stack_element_to_buffer(method, bci); 1137 print_to_stream(stream, buf); 1138 } 1139 1140 void java_lang_Throwable::print_stack_element(outputStream *st, methodOop method, int bci) { 1141 ResourceMark rm; 1142 char* buf = print_stack_element_to_buffer(method, bci); 1143 st->print_cr("%s", buf); 1144 } 1145 1146 void java_lang_Throwable::print_to_stream(Handle stream, const char* str) { 1147 if (stream.is_null()) { 1148 tty->print_cr("%s", str); 1149 } else { 1150 EXCEPTION_MARK; 1151 JavaValue result(T_VOID); 1152 Handle arg (THREAD, oopFactory::new_charArray(str, THREAD)); 1153 if (!HAS_PENDING_EXCEPTION) { 1154 JavaCalls::call_virtual(&result, 1155 stream, 1156 KlassHandle(THREAD, stream->klass()), 1157 vmSymbols::println_name(), 1158 vmSymbols::char_array_void_signature(), 1159 arg, 1160 THREAD); 1161 } 1162 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. 1163 if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION; 1164 } 1165 1166 } 1167 1168 1169 const char* java_lang_Throwable::no_stack_trace_message() { 1170 return "\t<<no stack trace available>>"; 1171 } 1172 1173 1174 // Currently used only for exceptions occurring during startup 1175 void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) { 1176 Thread *THREAD = Thread::current(); 1177 Handle h_throwable(THREAD, throwable); 1178 while (h_throwable.not_null()) { 1179 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable()))); 1180 if (result.is_null()) { 1181 st->print_cr(no_stack_trace_message()); 1182 return; 1183 } 1184 1185 while (result.not_null()) { 1186 objArrayHandle methods (THREAD, 1187 objArrayOop(result->obj_at(trace_methods_offset))); 1188 typeArrayHandle bcis (THREAD, 1189 typeArrayOop(result->obj_at(trace_bcis_offset))); 1190 1191 if (methods.is_null() || bcis.is_null()) { 1192 st->print_cr(no_stack_trace_message()); 1193 return; 1194 } 1195 1196 int length = methods()->length(); 1197 for (int index = 0; index < length; index++) { 1198 methodOop method = methodOop(methods()->obj_at(index)); 1199 if (method == NULL) goto handle_cause; 1200 int bci = bcis->ushort_at(index); 1201 print_stack_element(st, method, bci); 1202 } 1203 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset))); 1204 } 1205 handle_cause: 1206 { 1207 EXCEPTION_MARK; 1208 JavaValue result(T_OBJECT); 1209 JavaCalls::call_virtual(&result, 1210 h_throwable, 1211 KlassHandle(THREAD, h_throwable->klass()), 1212 vmSymbols::getCause_name(), 1213 vmSymbols::void_throwable_signature(), 1214 THREAD); 1215 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. 1216 if (HAS_PENDING_EXCEPTION) { 1217 CLEAR_PENDING_EXCEPTION; 1218 h_throwable = Handle(); 1219 } else { 1220 h_throwable = Handle(THREAD, (oop) result.get_jobject()); 1221 if (h_throwable.not_null()) { 1222 st->print("Caused by: "); 1223 print(h_throwable, st); 1224 st->cr(); 1225 } 1226 } 1227 } 1228 } 1229 } 1230 1231 1232 void java_lang_Throwable::print_stack_trace(oop throwable, oop print_stream) { 1233 // Note: this is no longer used in Merlin, but we support it for compatibility. 1234 Thread *thread = Thread::current(); 1235 Handle stream(thread, print_stream); 1236 objArrayHandle result (thread, objArrayOop(backtrace(throwable))); 1237 if (result.is_null()) { 1238 print_to_stream(stream, no_stack_trace_message()); 1239 return; 1240 } 1241 1242 while (result.not_null()) { 1243 objArrayHandle methods (thread, 1244 objArrayOop(result->obj_at(trace_methods_offset))); 1245 typeArrayHandle bcis (thread, 1246 typeArrayOop(result->obj_at(trace_bcis_offset))); 1247 1248 if (methods.is_null() || bcis.is_null()) { 1249 print_to_stream(stream, no_stack_trace_message()); 1250 return; 1251 } 1252 1253 int length = methods()->length(); 1254 for (int index = 0; index < length; index++) { 1255 methodOop method = methodOop(methods()->obj_at(index)); 1256 if (method == NULL) return; 1257 int bci = bcis->ushort_at(index); 1258 print_stack_element(stream, method, bci); 1259 } 1260 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset))); 1261 } 1262 } 1263 1264 // This class provides a simple wrapper over the internal structure of 1265 // exception backtrace to insulate users of the backtrace from needing 1266 // to know what it looks like. 1267 class BacktraceBuilder: public StackObj { 1268 private: 1269 Handle _backtrace; 1270 objArrayOop _head; 1271 objArrayOop _methods; 1272 typeArrayOop _bcis; 1273 int _index; 1274 bool _dirty; 1275 No_Safepoint_Verifier _nsv; 1276 1277 public: 1278 1279 enum { 1280 trace_methods_offset = java_lang_Throwable::trace_methods_offset, 1281 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset, 1282 trace_next_offset = java_lang_Throwable::trace_next_offset, 1283 trace_size = java_lang_Throwable::trace_size, 1284 trace_chunk_size = java_lang_Throwable::trace_chunk_size 1285 }; 1286 1287 // constructor for new backtrace 1288 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _dirty(false) { 1289 expand(CHECK); 1290 _backtrace = _head; 1291 _index = 0; 1292 } 1293 1294 void flush() { 1295 // The following appears to have been an optimization to save from 1296 // doing a barrier for each individual store into the _methods array, 1297 // but rather to do it for the entire array after the series of writes. 1298 // That optimization seems to have been lost when compressed oops was 1299 // implemented. However, the extra card-marks below was left in place, 1300 // but is now redundant because the individual stores into the 1301 // _methods array already execute the barrier code. CR 6918185 has 1302 // been filed so the original code may be restored by deferring the 1303 // barriers until after the entire sequence of stores, thus re-enabling 1304 // the intent of the original optimization. In the meantime the redundant 1305 // card mark below is now disabled. 1306 if (_dirty && _methods != NULL) { 1307 #if 0 1308 BarrierSet* bs = Universe::heap()->barrier_set(); 1309 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); 1310 bs->write_ref_array((HeapWord*)_methods->base(), _methods->length()); 1311 #endif 1312 _dirty = false; 1313 } 1314 } 1315 1316 void expand(TRAPS) { 1317 flush(); 1318 1319 objArrayHandle old_head(THREAD, _head); 1320 Pause_No_Safepoint_Verifier pnsv(&_nsv); 1321 1322 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); 1323 objArrayHandle new_head(THREAD, head); 1324 1325 objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK); 1326 objArrayHandle new_methods(THREAD, methods); 1327 1328 typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK); 1329 typeArrayHandle new_bcis(THREAD, bcis); 1330 1331 if (!old_head.is_null()) { 1332 old_head->obj_at_put(trace_next_offset, new_head()); 1333 } 1334 new_head->obj_at_put(trace_methods_offset, new_methods()); 1335 new_head->obj_at_put(trace_bcis_offset, new_bcis()); 1336 1337 _head = new_head(); 1338 _methods = new_methods(); 1339 _bcis = new_bcis(); 1340 _index = 0; 1341 } 1342 1343 oop backtrace() { 1344 flush(); 1345 return _backtrace(); 1346 } 1347 1348 inline void push(methodOop method, short bci, TRAPS) { 1349 if (_index >= trace_chunk_size) { 1350 methodHandle mhandle(THREAD, method); 1351 expand(CHECK); 1352 method = mhandle(); 1353 } 1354 1355 _methods->obj_at_put(_index, method); 1356 _bcis->ushort_at_put(_index, bci); 1357 _index++; 1358 _dirty = true; 1359 } 1360 1361 methodOop current_method() { 1362 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); 1363 return methodOop(_methods->obj_at(_index)); 1364 } 1365 1366 jushort current_bci() { 1367 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); 1368 return _bcis->ushort_at(_index); 1369 } 1370 }; 1371 1372 1373 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, TRAPS) { 1374 if (!StackTraceInThrowable) return; 1375 ResourceMark rm(THREAD); 1376 1377 // Start out by clearing the backtrace for this object, in case the VM 1378 // runs out of memory while allocating the stack trace 1379 set_backtrace(throwable(), NULL); 1380 if (JDK_Version::is_gte_jdk14x_version()) { 1381 // New since 1.4, clear lazily constructed Java level stacktrace if 1382 // refilling occurs 1383 clear_stacktrace(throwable()); 1384 } 1385 1386 int max_depth = MaxJavaStackTraceDepth; 1387 JavaThread* thread = (JavaThread*)THREAD; 1388 BacktraceBuilder bt(CHECK); 1389 1390 // Instead of using vframe directly, this version of fill_in_stack_trace 1391 // basically handles everything by hand. This significantly improved the 1392 // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows. 1393 // See bug 6333838 for more details. 1394 // The "ASSERT" here is to verify this method generates the exactly same stack 1395 // trace as utilizing vframe. 1396 #ifdef ASSERT 1397 vframeStream st(thread); 1398 methodHandle st_method(THREAD, st.method()); 1399 #endif 1400 int total_count = 0; 1401 RegisterMap map(thread, false); 1402 int decode_offset = 0; 1403 nmethod* nm = NULL; 1404 bool skip_fillInStackTrace_check = false; 1405 bool skip_throwableInit_check = false; 1406 1407 for (frame fr = thread->last_frame(); max_depth != total_count;) { 1408 methodOop method = NULL; 1409 int bci = 0; 1410 1411 // Compiled java method case. 1412 if (decode_offset != 0) { 1413 DebugInfoReadStream stream(nm, decode_offset); 1414 decode_offset = stream.read_int(); 1415 method = (methodOop)nm->oop_at(stream.read_int()); 1416 bci = stream.read_bci(); 1417 } else { 1418 if (fr.is_first_frame()) break; 1419 address pc = fr.pc(); 1420 if (fr.is_interpreted_frame()) { 1421 intptr_t bcx = fr.interpreter_frame_bcx(); 1422 method = fr.interpreter_frame_method(); 1423 bci = fr.is_bci(bcx) ? bcx : method->bci_from((address)bcx); 1424 fr = fr.sender(&map); 1425 } else { 1426 CodeBlob* cb = fr.cb(); 1427 // HMMM QQQ might be nice to have frame return nm as NULL if cb is non-NULL 1428 // but non nmethod 1429 fr = fr.sender(&map); 1430 if (cb == NULL || !cb->is_nmethod()) { 1431 continue; 1432 } 1433 nm = (nmethod*)cb; 1434 if (nm->method()->is_native()) { 1435 method = nm->method(); 1436 bci = 0; 1437 } else { 1438 PcDesc* pd = nm->pc_desc_at(pc); 1439 decode_offset = pd->scope_decode_offset(); 1440 // if decode_offset is not equal to 0, it will execute the 1441 // "compiled java method case" at the beginning of the loop. 1442 continue; 1443 } 1444 } 1445 } 1446 #ifdef ASSERT 1447 assert(st_method() == method && st.bci() == bci, 1448 "Wrong stack trace"); 1449 st.next(); 1450 // vframeStream::method isn't GC-safe so store off a copy 1451 // of the methodOop in case we GC. 1452 if (!st.at_end()) { 1453 st_method = st.method(); 1454 } 1455 #endif 1456 if (!skip_fillInStackTrace_check) { 1457 // check "fillInStackTrace" only once, so we negate the flag 1458 // after the first time check. 1459 skip_fillInStackTrace_check = true; 1460 if (method->name() == vmSymbols::fillInStackTrace_name()) { 1461 continue; 1462 } 1463 } 1464 // skip <init> methods of the exceptions klass. If there is <init> methods 1465 // that belongs to a superclass of the exception we are going to skipping 1466 // them in stack trace. This is simlar to classic VM. 1467 if (!skip_throwableInit_check) { 1468 if (method->name() == vmSymbols::object_initializer_name() && 1469 throwable->is_a(method->method_holder())) { 1470 continue; 1471 } else { 1472 // if no "Throwable.init()" method found, we stop checking it next time. 1473 skip_throwableInit_check = true; 1474 } 1475 } 1476 bt.push(method, bci, CHECK); 1477 total_count++; 1478 } 1479 1480 // Put completed stack trace into throwable object 1481 set_backtrace(throwable(), bt.backtrace()); 1482 } 1483 1484 void java_lang_Throwable::fill_in_stack_trace(Handle throwable) { 1485 // No-op if stack trace is disabled 1486 if (!StackTraceInThrowable) { 1487 return; 1488 } 1489 1490 // Disable stack traces for some preallocated out of memory errors 1491 if (!Universe::should_fill_in_stack_trace(throwable)) { 1492 return; 1493 } 1494 1495 PRESERVE_EXCEPTION_MARK; 1496 1497 JavaThread* thread = JavaThread::active(); 1498 fill_in_stack_trace(throwable, thread); 1499 // ignore exceptions thrown during stack trace filling 1500 CLEAR_PENDING_EXCEPTION; 1501 } 1502 1503 void java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) { 1504 // Allocate stack trace - backtrace is created but not filled in 1505 1506 // No-op if stack trace is disabled 1507 if (!StackTraceInThrowable) return; 1508 1509 objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK); 1510 objArrayHandle backtrace (THREAD, h_oop); 1511 objArrayOop m_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK); 1512 objArrayHandle methods (THREAD, m_oop); 1513 typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK); 1514 typeArrayHandle bcis(THREAD, b); 1515 1516 // backtrace has space for one chunk (next is NULL) 1517 backtrace->obj_at_put(trace_methods_offset, methods()); 1518 backtrace->obj_at_put(trace_bcis_offset, bcis()); 1519 set_backtrace(throwable(), backtrace()); 1520 } 1521 1522 1523 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) { 1524 // Fill in stack trace into preallocated backtrace (no GC) 1525 1526 // No-op if stack trace is disabled 1527 if (!StackTraceInThrowable) return; 1528 1529 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check"); 1530 1531 oop backtrace = java_lang_Throwable::backtrace(throwable()); 1532 assert(backtrace != NULL, "backtrace not preallocated"); 1533 1534 oop m = objArrayOop(backtrace)->obj_at(trace_methods_offset); 1535 objArrayOop methods = objArrayOop(m); 1536 assert(methods != NULL && methods->length() > 0, "method array not preallocated"); 1537 1538 oop b = objArrayOop(backtrace)->obj_at(trace_bcis_offset); 1539 typeArrayOop bcis = typeArrayOop(b); 1540 assert(bcis != NULL, "bci array not preallocated"); 1541 1542 assert(methods->length() == bcis->length(), "method and bci arrays should match"); 1543 1544 JavaThread* thread = JavaThread::current(); 1545 ResourceMark rm(thread); 1546 vframeStream st(thread); 1547 1548 // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init 1549 // methods as preallocated errors aren't created by "java" code. 1550 1551 // fill in as much stack trace as possible 1552 int max_chunks = MIN2(methods->length(), (int)MaxJavaStackTraceDepth); 1553 int chunk_count = 0; 1554 1555 for (;!st.at_end(); st.next()) { 1556 // add element 1557 bcis->ushort_at_put(chunk_count, st.bci()); 1558 methods->obj_at_put(chunk_count, st.method()); 1559 1560 chunk_count++; 1561 1562 // Bail-out for deep stacks 1563 if (chunk_count >= max_chunks) break; 1564 } 1565 } 1566 1567 1568 int java_lang_Throwable::get_stack_trace_depth(oop throwable, TRAPS) { 1569 if (throwable == NULL) { 1570 THROW_0(vmSymbols::java_lang_NullPointerException()); 1571 } 1572 objArrayOop chunk = objArrayOop(backtrace(throwable)); 1573 int depth = 0; 1574 if (chunk != NULL) { 1575 // Iterate over chunks and count full ones 1576 while (true) { 1577 objArrayOop next = objArrayOop(chunk->obj_at(trace_next_offset)); 1578 if (next == NULL) break; 1579 depth += trace_chunk_size; 1580 chunk = next; 1581 } 1582 assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check"); 1583 // Count element in remaining partial chunk 1584 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); 1585 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); 1586 assert(methods != NULL && bcis != NULL, "sanity check"); 1587 for (int i = 0; i < methods->length(); i++) { 1588 if (methods->obj_at(i) == NULL) break; 1589 depth++; 1590 } 1591 } 1592 return depth; 1593 } 1594 1595 1596 oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) { 1597 if (throwable == NULL) { 1598 THROW_0(vmSymbols::java_lang_NullPointerException()); 1599 } 1600 if (index < 0) { 1601 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); 1602 } 1603 // Compute how many chunks to skip and index into actual chunk 1604 objArrayOop chunk = objArrayOop(backtrace(throwable)); 1605 int skip_chunks = index / trace_chunk_size; 1606 int chunk_index = index % trace_chunk_size; 1607 while (chunk != NULL && skip_chunks > 0) { 1608 chunk = objArrayOop(chunk->obj_at(trace_next_offset)); 1609 skip_chunks--; 1610 } 1611 if (chunk == NULL) { 1612 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); 1613 } 1614 // Get method,bci from chunk 1615 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); 1616 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); 1617 assert(methods != NULL && bcis != NULL, "sanity check"); 1618 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index))); 1619 int bci = bcis->ushort_at(chunk_index); 1620 // Chunk can be partial full 1621 if (method.is_null()) { 1622 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); 1623 } 1624 1625 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0); 1626 return element; 1627 } 1628 1629 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) { 1630 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs 1631 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); 1632 1633 // Allocate java.lang.StackTraceElement instance 1634 klassOop k = SystemDictionary::StackTraceElement_klass(); 1635 assert(k != NULL, "must be loaded in 1.4+"); 1636 instanceKlassHandle ik (THREAD, k); 1637 if (ik->should_be_initialized()) { 1638 ik->initialize(CHECK_0); 1639 } 1640 1641 Handle element = ik->allocate_instance_handle(CHECK_0); 1642 // Fill in class name 1643 ResourceMark rm(THREAD); 1644 const char* str = instanceKlass::cast(method->method_holder())->external_name(); 1645 oop classname = StringTable::intern((char*) str, CHECK_0); 1646 java_lang_StackTraceElement::set_declaringClass(element(), classname); 1647 // Fill in method name 1648 oop methodname = StringTable::intern(method->name(), CHECK_0); 1649 java_lang_StackTraceElement::set_methodName(element(), methodname); 1650 // Fill in source file name 1651 Symbol* source = instanceKlass::cast(method->method_holder())->source_file_name(); 1652 oop filename = StringTable::intern(source, CHECK_0); 1653 java_lang_StackTraceElement::set_fileName(element(), filename); 1654 // File in source line number 1655 int line_number; 1656 if (method->is_native()) { 1657 // Negative value different from -1 below, enabling Java code in 1658 // class java.lang.StackTraceElement to distinguish "native" from 1659 // "no LineNumberTable". 1660 line_number = -2; 1661 } else { 1662 // Returns -1 if no LineNumberTable, and otherwise actual line number 1663 line_number = method->line_number_from_bci(bci); 1664 } 1665 java_lang_StackTraceElement::set_lineNumber(element(), line_number); 1666 1667 return element(); 1668 } 1669 1670 1671 void java_lang_reflect_AccessibleObject::compute_offsets() { 1672 klassOop k = SystemDictionary::reflect_AccessibleObject_klass(); 1673 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); 1674 } 1675 1676 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { 1677 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1678 return (jboolean) reflect->bool_field(override_offset); 1679 } 1680 1681 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) { 1682 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1683 reflect->bool_field_put(override_offset, (int) value); 1684 } 1685 1686 void java_lang_reflect_Method::compute_offsets() { 1687 klassOop k = SystemDictionary::reflect_Method_klass(); 1688 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 1689 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 1690 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); 1691 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); 1692 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); 1693 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); 1694 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 1695 // The generic signature and annotations fields are only present in 1.5 1696 signature_offset = -1; 1697 annotations_offset = -1; 1698 parameter_annotations_offset = -1; 1699 annotation_default_offset = -1; 1700 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); 1701 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 1702 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); 1703 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); 1704 } 1705 1706 Handle java_lang_reflect_Method::create(TRAPS) { 1707 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1708 klassOop klass = SystemDictionary::reflect_Method_klass(); 1709 // This class is eagerly initialized during VM initialization, since we keep a refence 1710 // to one of the methods 1711 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized"); 1712 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); 1713 } 1714 1715 oop java_lang_reflect_Method::clazz(oop reflect) { 1716 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1717 return reflect->obj_field(clazz_offset); 1718 } 1719 1720 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) { 1721 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1722 reflect->obj_field_put(clazz_offset, value); 1723 } 1724 1725 int java_lang_reflect_Method::slot(oop reflect) { 1726 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1727 return reflect->int_field(slot_offset); 1728 } 1729 1730 void java_lang_reflect_Method::set_slot(oop reflect, int value) { 1731 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1732 reflect->int_field_put(slot_offset, value); 1733 } 1734 1735 oop java_lang_reflect_Method::name(oop method) { 1736 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1737 return method->obj_field(name_offset); 1738 } 1739 1740 void java_lang_reflect_Method::set_name(oop method, oop value) { 1741 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1742 method->obj_field_put(name_offset, value); 1743 } 1744 1745 oop java_lang_reflect_Method::return_type(oop method) { 1746 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1747 return method->obj_field(returnType_offset); 1748 } 1749 1750 void java_lang_reflect_Method::set_return_type(oop method, oop value) { 1751 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1752 method->obj_field_put(returnType_offset, value); 1753 } 1754 1755 oop java_lang_reflect_Method::parameter_types(oop method) { 1756 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1757 return method->obj_field(parameterTypes_offset); 1758 } 1759 1760 void java_lang_reflect_Method::set_parameter_types(oop method, oop value) { 1761 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1762 method->obj_field_put(parameterTypes_offset, value); 1763 } 1764 1765 oop java_lang_reflect_Method::exception_types(oop method) { 1766 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1767 return method->obj_field(exceptionTypes_offset); 1768 } 1769 1770 void java_lang_reflect_Method::set_exception_types(oop method, oop value) { 1771 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1772 method->obj_field_put(exceptionTypes_offset, value); 1773 } 1774 1775 int java_lang_reflect_Method::modifiers(oop method) { 1776 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1777 return method->int_field(modifiers_offset); 1778 } 1779 1780 void java_lang_reflect_Method::set_modifiers(oop method, int value) { 1781 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1782 method->int_field_put(modifiers_offset, value); 1783 } 1784 1785 bool java_lang_reflect_Method::has_signature_field() { 1786 return (signature_offset >= 0); 1787 } 1788 1789 oop java_lang_reflect_Method::signature(oop method) { 1790 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1791 assert(has_signature_field(), "signature field must be present"); 1792 return method->obj_field(signature_offset); 1793 } 1794 1795 void java_lang_reflect_Method::set_signature(oop method, oop value) { 1796 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1797 assert(has_signature_field(), "signature field must be present"); 1798 method->obj_field_put(signature_offset, value); 1799 } 1800 1801 bool java_lang_reflect_Method::has_annotations_field() { 1802 return (annotations_offset >= 0); 1803 } 1804 1805 oop java_lang_reflect_Method::annotations(oop method) { 1806 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1807 assert(has_annotations_field(), "annotations field must be present"); 1808 return method->obj_field(annotations_offset); 1809 } 1810 1811 void java_lang_reflect_Method::set_annotations(oop method, oop value) { 1812 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1813 assert(has_annotations_field(), "annotations field must be present"); 1814 method->obj_field_put(annotations_offset, value); 1815 } 1816 1817 bool java_lang_reflect_Method::has_parameter_annotations_field() { 1818 return (parameter_annotations_offset >= 0); 1819 } 1820 1821 oop java_lang_reflect_Method::parameter_annotations(oop method) { 1822 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1823 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 1824 return method->obj_field(parameter_annotations_offset); 1825 } 1826 1827 void java_lang_reflect_Method::set_parameter_annotations(oop method, oop value) { 1828 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1829 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 1830 method->obj_field_put(parameter_annotations_offset, value); 1831 } 1832 1833 bool java_lang_reflect_Method::has_annotation_default_field() { 1834 return (annotation_default_offset >= 0); 1835 } 1836 1837 oop java_lang_reflect_Method::annotation_default(oop method) { 1838 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1839 assert(has_annotation_default_field(), "annotation default field must be present"); 1840 return method->obj_field(annotation_default_offset); 1841 } 1842 1843 void java_lang_reflect_Method::set_annotation_default(oop method, oop value) { 1844 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1845 assert(has_annotation_default_field(), "annotation default field must be present"); 1846 method->obj_field_put(annotation_default_offset, value); 1847 } 1848 1849 void java_lang_reflect_Constructor::compute_offsets() { 1850 klassOop k = SystemDictionary::reflect_Constructor_klass(); 1851 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 1852 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); 1853 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); 1854 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); 1855 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 1856 // The generic signature and annotations fields are only present in 1.5 1857 signature_offset = -1; 1858 annotations_offset = -1; 1859 parameter_annotations_offset = -1; 1860 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); 1861 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 1862 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); 1863 } 1864 1865 Handle java_lang_reflect_Constructor::create(TRAPS) { 1866 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1867 Symbol* name = vmSymbols::java_lang_reflect_Constructor(); 1868 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 1869 instanceKlassHandle klass (THREAD, k); 1870 // Ensure it is initialized 1871 klass->initialize(CHECK_NH); 1872 return klass->allocate_instance_handle(CHECK_NH); 1873 } 1874 1875 oop java_lang_reflect_Constructor::clazz(oop reflect) { 1876 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1877 return reflect->obj_field(clazz_offset); 1878 } 1879 1880 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) { 1881 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1882 reflect->obj_field_put(clazz_offset, value); 1883 } 1884 1885 oop java_lang_reflect_Constructor::parameter_types(oop constructor) { 1886 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1887 return constructor->obj_field(parameterTypes_offset); 1888 } 1889 1890 void java_lang_reflect_Constructor::set_parameter_types(oop constructor, oop value) { 1891 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1892 constructor->obj_field_put(parameterTypes_offset, value); 1893 } 1894 1895 oop java_lang_reflect_Constructor::exception_types(oop constructor) { 1896 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1897 return constructor->obj_field(exceptionTypes_offset); 1898 } 1899 1900 void java_lang_reflect_Constructor::set_exception_types(oop constructor, oop value) { 1901 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1902 constructor->obj_field_put(exceptionTypes_offset, value); 1903 } 1904 1905 int java_lang_reflect_Constructor::slot(oop reflect) { 1906 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1907 return reflect->int_field(slot_offset); 1908 } 1909 1910 void java_lang_reflect_Constructor::set_slot(oop reflect, int value) { 1911 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1912 reflect->int_field_put(slot_offset, value); 1913 } 1914 1915 int java_lang_reflect_Constructor::modifiers(oop constructor) { 1916 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1917 return constructor->int_field(modifiers_offset); 1918 } 1919 1920 void java_lang_reflect_Constructor::set_modifiers(oop constructor, int value) { 1921 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1922 constructor->int_field_put(modifiers_offset, value); 1923 } 1924 1925 bool java_lang_reflect_Constructor::has_signature_field() { 1926 return (signature_offset >= 0); 1927 } 1928 1929 oop java_lang_reflect_Constructor::signature(oop constructor) { 1930 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1931 assert(has_signature_field(), "signature field must be present"); 1932 return constructor->obj_field(signature_offset); 1933 } 1934 1935 void java_lang_reflect_Constructor::set_signature(oop constructor, oop value) { 1936 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1937 assert(has_signature_field(), "signature field must be present"); 1938 constructor->obj_field_put(signature_offset, value); 1939 } 1940 1941 bool java_lang_reflect_Constructor::has_annotations_field() { 1942 return (annotations_offset >= 0); 1943 } 1944 1945 oop java_lang_reflect_Constructor::annotations(oop constructor) { 1946 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1947 assert(has_annotations_field(), "annotations field must be present"); 1948 return constructor->obj_field(annotations_offset); 1949 } 1950 1951 void java_lang_reflect_Constructor::set_annotations(oop constructor, oop value) { 1952 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1953 assert(has_annotations_field(), "annotations field must be present"); 1954 constructor->obj_field_put(annotations_offset, value); 1955 } 1956 1957 bool java_lang_reflect_Constructor::has_parameter_annotations_field() { 1958 return (parameter_annotations_offset >= 0); 1959 } 1960 1961 oop java_lang_reflect_Constructor::parameter_annotations(oop method) { 1962 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1963 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 1964 return method->obj_field(parameter_annotations_offset); 1965 } 1966 1967 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) { 1968 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1969 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 1970 method->obj_field_put(parameter_annotations_offset, value); 1971 } 1972 1973 void java_lang_reflect_Field::compute_offsets() { 1974 klassOop k = SystemDictionary::reflect_Field_klass(); 1975 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 1976 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 1977 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); 1978 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); 1979 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 1980 // The generic signature and annotations fields are only present in 1.5 1981 signature_offset = -1; 1982 annotations_offset = -1; 1983 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); 1984 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 1985 } 1986 1987 Handle java_lang_reflect_Field::create(TRAPS) { 1988 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1989 Symbol* name = vmSymbols::java_lang_reflect_Field(); 1990 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 1991 instanceKlassHandle klass (THREAD, k); 1992 // Ensure it is initialized 1993 klass->initialize(CHECK_NH); 1994 return klass->allocate_instance_handle(CHECK_NH); 1995 } 1996 1997 oop java_lang_reflect_Field::clazz(oop reflect) { 1998 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1999 return reflect->obj_field(clazz_offset); 2000 } 2001 2002 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) { 2003 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2004 reflect->obj_field_put(clazz_offset, value); 2005 } 2006 2007 oop java_lang_reflect_Field::name(oop field) { 2008 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2009 return field->obj_field(name_offset); 2010 } 2011 2012 void java_lang_reflect_Field::set_name(oop field, oop value) { 2013 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2014 field->obj_field_put(name_offset, value); 2015 } 2016 2017 oop java_lang_reflect_Field::type(oop field) { 2018 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2019 return field->obj_field(type_offset); 2020 } 2021 2022 void java_lang_reflect_Field::set_type(oop field, oop value) { 2023 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2024 field->obj_field_put(type_offset, value); 2025 } 2026 2027 int java_lang_reflect_Field::slot(oop reflect) { 2028 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2029 return reflect->int_field(slot_offset); 2030 } 2031 2032 void java_lang_reflect_Field::set_slot(oop reflect, int value) { 2033 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2034 reflect->int_field_put(slot_offset, value); 2035 } 2036 2037 int java_lang_reflect_Field::modifiers(oop field) { 2038 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2039 return field->int_field(modifiers_offset); 2040 } 2041 2042 void java_lang_reflect_Field::set_modifiers(oop field, int value) { 2043 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2044 field->int_field_put(modifiers_offset, value); 2045 } 2046 2047 bool java_lang_reflect_Field::has_signature_field() { 2048 return (signature_offset >= 0); 2049 } 2050 2051 oop java_lang_reflect_Field::signature(oop field) { 2052 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2053 assert(has_signature_field(), "signature field must be present"); 2054 return field->obj_field(signature_offset); 2055 } 2056 2057 void java_lang_reflect_Field::set_signature(oop field, oop value) { 2058 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2059 assert(has_signature_field(), "signature field must be present"); 2060 field->obj_field_put(signature_offset, value); 2061 } 2062 2063 bool java_lang_reflect_Field::has_annotations_field() { 2064 return (annotations_offset >= 0); 2065 } 2066 2067 oop java_lang_reflect_Field::annotations(oop field) { 2068 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2069 assert(has_annotations_field(), "annotations field must be present"); 2070 return field->obj_field(annotations_offset); 2071 } 2072 2073 void java_lang_reflect_Field::set_annotations(oop field, oop value) { 2074 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2075 assert(has_annotations_field(), "annotations field must be present"); 2076 field->obj_field_put(annotations_offset, value); 2077 } 2078 2079 2080 void sun_reflect_ConstantPool::compute_offsets() { 2081 klassOop k = SystemDictionary::reflect_ConstantPool_klass(); 2082 // This null test can be removed post beta 2083 if (k != NULL) { 2084 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature()); 2085 } 2086 } 2087 2088 2089 Handle sun_reflect_ConstantPool::create(TRAPS) { 2090 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2091 klassOop k = SystemDictionary::reflect_ConstantPool_klass(); 2092 instanceKlassHandle klass (THREAD, k); 2093 // Ensure it is initialized 2094 klass->initialize(CHECK_NH); 2095 return klass->allocate_instance_handle(CHECK_NH); 2096 } 2097 2098 2099 oop sun_reflect_ConstantPool::cp_oop(oop reflect) { 2100 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2101 return reflect->obj_field(_cp_oop_offset); 2102 } 2103 2104 2105 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) { 2106 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2107 reflect->obj_field_put(_cp_oop_offset, value); 2108 } 2109 2110 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { 2111 klassOop k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); 2112 // This null test can be removed post beta 2113 if (k != NULL) { 2114 compute_offset(_base_offset, k, 2115 vmSymbols::base_name(), vmSymbols::object_signature()); 2116 } 2117 } 2118 2119 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { 2120 klassOop k = SystemDictionary::box_klass(type); 2121 if (k == NULL) return NULL; 2122 instanceKlassHandle h (THREAD, k); 2123 if (!h->is_initialized()) h->initialize(CHECK_0); 2124 return h->allocate_instance(THREAD); 2125 } 2126 2127 2128 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) { 2129 oop box = initialize_and_allocate(type, CHECK_0); 2130 if (box == NULL) return NULL; 2131 switch (type) { 2132 case T_BOOLEAN: 2133 box->bool_field_put(value_offset, value->z); 2134 break; 2135 case T_CHAR: 2136 box->char_field_put(value_offset, value->c); 2137 break; 2138 case T_FLOAT: 2139 box->float_field_put(value_offset, value->f); 2140 break; 2141 case T_DOUBLE: 2142 box->double_field_put(long_value_offset, value->d); 2143 break; 2144 case T_BYTE: 2145 box->byte_field_put(value_offset, value->b); 2146 break; 2147 case T_SHORT: 2148 box->short_field_put(value_offset, value->s); 2149 break; 2150 case T_INT: 2151 box->int_field_put(value_offset, value->i); 2152 break; 2153 case T_LONG: 2154 box->long_field_put(long_value_offset, value->j); 2155 break; 2156 default: 2157 return NULL; 2158 } 2159 return box; 2160 } 2161 2162 2163 BasicType java_lang_boxing_object::basic_type(oop box) { 2164 if (box == NULL) return T_ILLEGAL; 2165 BasicType type = SystemDictionary::box_klass_type(box->klass()); 2166 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt 2167 return T_ILLEGAL; 2168 return type; 2169 } 2170 2171 2172 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) { 2173 BasicType type = SystemDictionary::box_klass_type(box->klass()); 2174 switch (type) { 2175 case T_BOOLEAN: 2176 value->z = box->bool_field(value_offset); 2177 break; 2178 case T_CHAR: 2179 value->c = box->char_field(value_offset); 2180 break; 2181 case T_FLOAT: 2182 value->f = box->float_field(value_offset); 2183 break; 2184 case T_DOUBLE: 2185 value->d = box->double_field(long_value_offset); 2186 break; 2187 case T_BYTE: 2188 value->b = box->byte_field(value_offset); 2189 break; 2190 case T_SHORT: 2191 value->s = box->short_field(value_offset); 2192 break; 2193 case T_INT: 2194 value->i = box->int_field(value_offset); 2195 break; 2196 case T_LONG: 2197 value->j = box->long_field(long_value_offset); 2198 break; 2199 default: 2200 return T_ILLEGAL; 2201 } // end switch 2202 return type; 2203 } 2204 2205 2206 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) { 2207 BasicType type = SystemDictionary::box_klass_type(box->klass()); 2208 switch (type) { 2209 case T_BOOLEAN: 2210 box->bool_field_put(value_offset, value->z); 2211 break; 2212 case T_CHAR: 2213 box->char_field_put(value_offset, value->c); 2214 break; 2215 case T_FLOAT: 2216 box->float_field_put(value_offset, value->f); 2217 break; 2218 case T_DOUBLE: 2219 box->double_field_put(long_value_offset, value->d); 2220 break; 2221 case T_BYTE: 2222 box->byte_field_put(value_offset, value->b); 2223 break; 2224 case T_SHORT: 2225 box->short_field_put(value_offset, value->s); 2226 break; 2227 case T_INT: 2228 box->int_field_put(value_offset, value->i); 2229 break; 2230 case T_LONG: 2231 box->long_field_put(long_value_offset, value->j); 2232 break; 2233 default: 2234 return T_ILLEGAL; 2235 } // end switch 2236 return type; 2237 } 2238 2239 2240 void java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream* st) { 2241 switch (type) { 2242 case T_BOOLEAN: st->print("%s", value->z ? "true" : "false"); break; 2243 case T_CHAR: st->print("%d", value->c); break; 2244 case T_BYTE: st->print("%d", value->b); break; 2245 case T_SHORT: st->print("%d", value->s); break; 2246 case T_INT: st->print("%d", value->i); break; 2247 case T_LONG: st->print(INT64_FORMAT, value->j); break; 2248 case T_FLOAT: st->print("%f", value->f); break; 2249 case T_DOUBLE: st->print("%lf", value->d); break; 2250 default: st->print("type %d?", type); break; 2251 } 2252 } 2253 2254 2255 // Support for java_lang_ref_Reference 2256 oop java_lang_ref_Reference::pending_list_lock() { 2257 instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass()); 2258 address addr = ik->static_field_addr(static_lock_offset); 2259 if (UseCompressedOops) { 2260 return oopDesc::load_decode_heap_oop((narrowOop *)addr); 2261 } else { 2262 return oopDesc::load_decode_heap_oop((oop*)addr); 2263 } 2264 } 2265 2266 HeapWord *java_lang_ref_Reference::pending_list_addr() { 2267 instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass()); 2268 address addr = ik->static_field_addr(static_pending_offset); 2269 // XXX This might not be HeapWord aligned, almost rather be char *. 2270 return (HeapWord*)addr; 2271 } 2272 2273 oop java_lang_ref_Reference::pending_list() { 2274 char *addr = (char *)pending_list_addr(); 2275 if (UseCompressedOops) { 2276 return oopDesc::load_decode_heap_oop((narrowOop *)addr); 2277 } else { 2278 return oopDesc::load_decode_heap_oop((oop*)addr); 2279 } 2280 } 2281 2282 2283 // Support for java_lang_ref_SoftReference 2284 2285 jlong java_lang_ref_SoftReference::timestamp(oop ref) { 2286 return ref->long_field(timestamp_offset); 2287 } 2288 2289 jlong java_lang_ref_SoftReference::clock() { 2290 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass()); 2291 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); 2292 return *offset; 2293 } 2294 2295 void java_lang_ref_SoftReference::set_clock(jlong value) { 2296 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass()); 2297 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); 2298 *offset = value; 2299 } 2300 2301 2302 // Support for java_lang_invoke_MethodHandle 2303 2304 int java_lang_invoke_MethodHandle::_type_offset; 2305 int java_lang_invoke_MethodHandle::_vmtarget_offset; 2306 int java_lang_invoke_MethodHandle::_vmentry_offset; 2307 int java_lang_invoke_MethodHandle::_vmslots_offset; 2308 2309 int java_lang_invoke_MemberName::_clazz_offset; 2310 int java_lang_invoke_MemberName::_name_offset; 2311 int java_lang_invoke_MemberName::_type_offset; 2312 int java_lang_invoke_MemberName::_flags_offset; 2313 int java_lang_invoke_MemberName::_vmtarget_offset; 2314 int java_lang_invoke_MemberName::_vmindex_offset; 2315 2316 int java_lang_invoke_DirectMethodHandle::_vmindex_offset; 2317 2318 int java_lang_invoke_BoundMethodHandle::_argument_offset; 2319 int java_lang_invoke_BoundMethodHandle::_vmargslot_offset; 2320 2321 int java_lang_invoke_AdapterMethodHandle::_conversion_offset; 2322 2323 void java_lang_invoke_MethodHandle::compute_offsets() { 2324 klassOop k = SystemDictionary::MethodHandle_klass(); 2325 if (k != NULL && EnableInvokeDynamic) { 2326 bool allow_super = false; 2327 if (AllowTransitionalJSR292) allow_super = true; // temporary, to access java.dyn.MethodHandleImpl 2328 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature(), allow_super); 2329 compute_offset(_vmtarget_offset, k, vmSymbols::vmtarget_name(), vmSymbols::object_signature(), allow_super); 2330 compute_offset(_vmentry_offset, k, vmSymbols::vmentry_name(), vmSymbols::machine_word_signature(), allow_super); 2331 2332 // Note: MH.vmslots (if it is present) is a hoisted copy of MH.type.form.vmslots. 2333 // It is optional pending experiments to keep or toss. 2334 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), allow_super); 2335 } 2336 } 2337 2338 void java_lang_invoke_MemberName::compute_offsets() { 2339 klassOop k = SystemDictionary::MemberName_klass(); 2340 if (k != NULL && EnableInvokeDynamic) { 2341 compute_offset(_clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 2342 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 2343 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::object_signature()); 2344 compute_offset(_flags_offset, k, vmSymbols::flags_name(), vmSymbols::int_signature()); 2345 compute_offset(_vmtarget_offset, k, vmSymbols::vmtarget_name(), vmSymbols::object_signature()); 2346 compute_offset(_vmindex_offset, k, vmSymbols::vmindex_name(), vmSymbols::int_signature()); 2347 } 2348 } 2349 2350 void java_lang_invoke_DirectMethodHandle::compute_offsets() { 2351 klassOop k = SystemDictionary::DirectMethodHandle_klass(); 2352 if (k != NULL && EnableInvokeDynamic) { 2353 compute_offset(_vmindex_offset, k, vmSymbols::vmindex_name(), vmSymbols::int_signature(), true); 2354 } 2355 } 2356 2357 void java_lang_invoke_BoundMethodHandle::compute_offsets() { 2358 klassOop k = SystemDictionary::BoundMethodHandle_klass(); 2359 if (k != NULL && EnableInvokeDynamic) { 2360 compute_offset(_vmargslot_offset, k, vmSymbols::vmargslot_name(), vmSymbols::int_signature(), true); 2361 compute_offset(_argument_offset, k, vmSymbols::argument_name(), vmSymbols::object_signature(), true); 2362 } 2363 } 2364 2365 void java_lang_invoke_AdapterMethodHandle::compute_offsets() { 2366 klassOop k = SystemDictionary::AdapterMethodHandle_klass(); 2367 if (k != NULL && EnableInvokeDynamic) { 2368 compute_offset(_conversion_offset, k, vmSymbols::conversion_name(), vmSymbols::int_signature(), true); 2369 } 2370 } 2371 2372 oop java_lang_invoke_MethodHandle::type(oop mh) { 2373 return mh->obj_field(_type_offset); 2374 } 2375 2376 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) { 2377 mh->obj_field_put(_type_offset, mtype); 2378 } 2379 2380 int java_lang_invoke_MethodHandle::vmslots(oop mh) { 2381 int vmslots_offset = _vmslots_offset; 2382 if (vmslots_offset != 0) { 2383 #ifdef ASSERT 2384 int x = mh->int_field(vmslots_offset); 2385 int y = compute_vmslots(mh); 2386 assert(x == y, "correct hoisted value"); 2387 #endif 2388 return mh->int_field(vmslots_offset); 2389 } else { 2390 return compute_vmslots(mh); 2391 } 2392 } 2393 2394 // if MH.vmslots exists, hoist into it the value of type.form.vmslots 2395 void java_lang_invoke_MethodHandle::init_vmslots(oop mh) { 2396 int vmslots_offset = _vmslots_offset; 2397 if (vmslots_offset != 0) { 2398 mh->int_field_put(vmslots_offset, compute_vmslots(mh)); 2399 } 2400 } 2401 2402 // fetch type.form.vmslots, which is the number of JVM stack slots 2403 // required to carry the arguments of this MH 2404 int java_lang_invoke_MethodHandle::compute_vmslots(oop mh) { 2405 oop mtype = type(mh); 2406 if (mtype == NULL) return 0; // Java code would get NPE 2407 oop form = java_lang_invoke_MethodType::form(mtype); 2408 if (form == NULL) return 0; // Java code would get NPE 2409 return java_lang_invoke_MethodTypeForm::vmslots(form); 2410 } 2411 2412 // fetch the low-level entry point for this mh 2413 MethodHandleEntry* java_lang_invoke_MethodHandle::vmentry(oop mh) { 2414 return (MethodHandleEntry*) mh->address_field(_vmentry_offset); 2415 } 2416 2417 void java_lang_invoke_MethodHandle::set_vmentry(oop mh, MethodHandleEntry* me) { 2418 assert(_vmentry_offset != 0, "must be present"); 2419 2420 // This is always the final step that initializes a valid method handle: 2421 mh->release_address_field_put(_vmentry_offset, (address) me); 2422 2423 // There should be enough memory barriers on exit from native methods 2424 // to ensure that the MH is fully initialized to all threads before 2425 // Java code can publish it in global data structures. 2426 // But just in case, we use release_address_field_put. 2427 } 2428 2429 /// MemberName accessors 2430 2431 oop java_lang_invoke_MemberName::clazz(oop mname) { 2432 assert(is_instance(mname), "wrong type"); 2433 return mname->obj_field(_clazz_offset); 2434 } 2435 2436 void java_lang_invoke_MemberName::set_clazz(oop mname, oop clazz) { 2437 assert(is_instance(mname), "wrong type"); 2438 mname->obj_field_put(_clazz_offset, clazz); 2439 } 2440 2441 oop java_lang_invoke_MemberName::name(oop mname) { 2442 assert(is_instance(mname), "wrong type"); 2443 return mname->obj_field(_name_offset); 2444 } 2445 2446 void java_lang_invoke_MemberName::set_name(oop mname, oop name) { 2447 assert(is_instance(mname), "wrong type"); 2448 mname->obj_field_put(_name_offset, name); 2449 } 2450 2451 oop java_lang_invoke_MemberName::type(oop mname) { 2452 assert(is_instance(mname), "wrong type"); 2453 return mname->obj_field(_type_offset); 2454 } 2455 2456 void java_lang_invoke_MemberName::set_type(oop mname, oop type) { 2457 assert(is_instance(mname), "wrong type"); 2458 mname->obj_field_put(_type_offset, type); 2459 } 2460 2461 int java_lang_invoke_MemberName::flags(oop mname) { 2462 assert(is_instance(mname), "wrong type"); 2463 return mname->int_field(_flags_offset); 2464 } 2465 2466 void java_lang_invoke_MemberName::set_flags(oop mname, int flags) { 2467 assert(is_instance(mname), "wrong type"); 2468 mname->int_field_put(_flags_offset, flags); 2469 } 2470 2471 oop java_lang_invoke_MemberName::vmtarget(oop mname) { 2472 assert(is_instance(mname), "wrong type"); 2473 return mname->obj_field(_vmtarget_offset); 2474 } 2475 2476 void java_lang_invoke_MemberName::set_vmtarget(oop mname, oop ref) { 2477 assert(is_instance(mname), "wrong type"); 2478 mname->obj_field_put(_vmtarget_offset, ref); 2479 } 2480 2481 int java_lang_invoke_MemberName::vmindex(oop mname) { 2482 assert(is_instance(mname), "wrong type"); 2483 return mname->int_field(_vmindex_offset); 2484 } 2485 2486 void java_lang_invoke_MemberName::set_vmindex(oop mname, int index) { 2487 assert(is_instance(mname), "wrong type"); 2488 mname->int_field_put(_vmindex_offset, index); 2489 } 2490 2491 oop java_lang_invoke_MethodHandle::vmtarget(oop mh) { 2492 assert(is_instance(mh), "MH only"); 2493 return mh->obj_field(_vmtarget_offset); 2494 } 2495 2496 void java_lang_invoke_MethodHandle::set_vmtarget(oop mh, oop ref) { 2497 assert(is_instance(mh), "MH only"); 2498 mh->obj_field_put(_vmtarget_offset, ref); 2499 } 2500 2501 int java_lang_invoke_DirectMethodHandle::vmindex(oop mh) { 2502 assert(is_instance(mh), "DMH only"); 2503 return mh->int_field(_vmindex_offset); 2504 } 2505 2506 void java_lang_invoke_DirectMethodHandle::set_vmindex(oop mh, int index) { 2507 assert(is_instance(mh), "DMH only"); 2508 mh->int_field_put(_vmindex_offset, index); 2509 } 2510 2511 int java_lang_invoke_BoundMethodHandle::vmargslot(oop mh) { 2512 assert(is_instance(mh), "BMH only"); 2513 return mh->int_field(_vmargslot_offset); 2514 } 2515 2516 oop java_lang_invoke_BoundMethodHandle::argument(oop mh) { 2517 assert(is_instance(mh), "BMH only"); 2518 return mh->obj_field(_argument_offset); 2519 } 2520 2521 int java_lang_invoke_AdapterMethodHandle::conversion(oop mh) { 2522 assert(is_instance(mh), "AMH only"); 2523 return mh->int_field(_conversion_offset); 2524 } 2525 2526 void java_lang_invoke_AdapterMethodHandle::set_conversion(oop mh, int conv) { 2527 assert(is_instance(mh), "AMH only"); 2528 mh->int_field_put(_conversion_offset, conv); 2529 } 2530 2531 2532 // Support for java_lang_invoke_MethodType 2533 2534 int java_lang_invoke_MethodType::_rtype_offset; 2535 int java_lang_invoke_MethodType::_ptypes_offset; 2536 int java_lang_invoke_MethodType::_form_offset; 2537 2538 void java_lang_invoke_MethodType::compute_offsets() { 2539 klassOop k = SystemDictionary::MethodType_klass(); 2540 if (k != NULL) { 2541 compute_offset(_rtype_offset, k, vmSymbols::rtype_name(), vmSymbols::class_signature()); 2542 compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature()); 2543 compute_offset(_form_offset, k, vmSymbols::form_name(), vmSymbols::java_lang_invoke_MethodTypeForm_signature()); 2544 } 2545 } 2546 2547 void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) { 2548 st->print("("); 2549 objArrayOop pts = ptypes(mt); 2550 for (int i = 0, limit = pts->length(); i < limit; i++) { 2551 java_lang_Class::print_signature(pts->obj_at(i), st); 2552 } 2553 st->print(")"); 2554 java_lang_Class::print_signature(rtype(mt), st); 2555 } 2556 2557 Symbol* java_lang_invoke_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) { 2558 ResourceMark rm; 2559 stringStream buffer(128); 2560 print_signature(mt, &buffer); 2561 const char* sigstr = buffer.base(); 2562 int siglen = (int) buffer.size(); 2563 Symbol *name; 2564 if (!intern_if_not_found) { 2565 name = SymbolTable::probe(sigstr, siglen); 2566 } else { 2567 name = SymbolTable::new_symbol(sigstr, siglen, THREAD); 2568 } 2569 return name; 2570 } 2571 2572 oop java_lang_invoke_MethodType::rtype(oop mt) { 2573 assert(is_instance(mt), "must be a MethodType"); 2574 return mt->obj_field(_rtype_offset); 2575 } 2576 2577 objArrayOop java_lang_invoke_MethodType::ptypes(oop mt) { 2578 assert(is_instance(mt), "must be a MethodType"); 2579 return (objArrayOop) mt->obj_field(_ptypes_offset); 2580 } 2581 2582 oop java_lang_invoke_MethodType::form(oop mt) { 2583 assert(is_instance(mt), "must be a MethodType"); 2584 return mt->obj_field(_form_offset); 2585 } 2586 2587 oop java_lang_invoke_MethodType::ptype(oop mt, int idx) { 2588 return ptypes(mt)->obj_at(idx); 2589 } 2590 2591 int java_lang_invoke_MethodType::ptype_count(oop mt) { 2592 return ptypes(mt)->length(); 2593 } 2594 2595 2596 2597 // Support for java_lang_invoke_MethodTypeForm 2598 2599 int java_lang_invoke_MethodTypeForm::_vmslots_offset; 2600 int java_lang_invoke_MethodTypeForm::_erasedType_offset; 2601 int java_lang_invoke_MethodTypeForm::_genericInvoker_offset; 2602 2603 void java_lang_invoke_MethodTypeForm::compute_offsets() { 2604 klassOop k = SystemDictionary::MethodTypeForm_klass(); 2605 if (k != NULL) { 2606 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), true); 2607 compute_optional_offset(_erasedType_offset, k, vmSymbols::erasedType_name(), vmSymbols::java_lang_invoke_MethodType_signature(), true); 2608 compute_optional_offset(_genericInvoker_offset, k, vmSymbols::genericInvoker_name(), vmSymbols::java_lang_invoke_MethodHandle_signature(), true); 2609 if (_genericInvoker_offset == 0) _genericInvoker_offset = -1; // set to explicit "empty" value 2610 } 2611 } 2612 2613 int java_lang_invoke_MethodTypeForm::vmslots(oop mtform) { 2614 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only"); 2615 return mtform->int_field(_vmslots_offset); 2616 } 2617 2618 oop java_lang_invoke_MethodTypeForm::erasedType(oop mtform) { 2619 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only"); 2620 return mtform->obj_field(_erasedType_offset); 2621 } 2622 2623 oop java_lang_invoke_MethodTypeForm::genericInvoker(oop mtform) { 2624 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only"); 2625 return mtform->obj_field(_genericInvoker_offset); 2626 } 2627 2628 2629 // Support for java_lang_invoke_CallSite 2630 2631 int java_lang_invoke_CallSite::_target_offset; 2632 2633 void java_lang_invoke_CallSite::compute_offsets() { 2634 if (!EnableInvokeDynamic) return; 2635 klassOop k = SystemDictionary::CallSite_klass(); 2636 if (k != NULL) { 2637 compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature()); 2638 } 2639 } 2640 2641 oop java_lang_invoke_CallSite::target(oop site) { 2642 return site->obj_field(_target_offset); 2643 } 2644 2645 void java_lang_invoke_CallSite::set_target(oop site, oop target) { 2646 site->obj_field_put(_target_offset, target); 2647 } 2648 2649 2650 // Support for java_security_AccessControlContext 2651 2652 int java_security_AccessControlContext::_context_offset = 0; 2653 int java_security_AccessControlContext::_privilegedContext_offset = 0; 2654 int java_security_AccessControlContext::_isPrivileged_offset = 0; 2655 2656 void java_security_AccessControlContext::compute_offsets() { 2657 assert(_isPrivileged_offset == 0, "offsets should be initialized only once"); 2658 fieldDescriptor fd; 2659 instanceKlass* ik = instanceKlass::cast(SystemDictionary::AccessControlContext_klass()); 2660 2661 if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) { 2662 fatal("Invalid layout of java.security.AccessControlContext"); 2663 } 2664 _context_offset = fd.offset(); 2665 2666 if (!ik->find_local_field(vmSymbols::privilegedContext_name(), vmSymbols::accesscontrolcontext_signature(), &fd)) { 2667 fatal("Invalid layout of java.security.AccessControlContext"); 2668 } 2669 _privilegedContext_offset = fd.offset(); 2670 2671 if (!ik->find_local_field(vmSymbols::isPrivileged_name(), vmSymbols::bool_signature(), &fd)) { 2672 fatal("Invalid layout of java.security.AccessControlContext"); 2673 } 2674 _isPrivileged_offset = fd.offset(); 2675 } 2676 2677 2678 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) { 2679 assert(_isPrivileged_offset != 0, "offsets should have been initialized"); 2680 // Ensure klass is initialized 2681 instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); 2682 // Allocate result 2683 oop result = instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); 2684 // Fill in values 2685 result->obj_field_put(_context_offset, context()); 2686 result->obj_field_put(_privilegedContext_offset, privileged_context()); 2687 result->bool_field_put(_isPrivileged_offset, isPrivileged); 2688 return result; 2689 } 2690 2691 2692 // Support for java_lang_ClassLoader 2693 2694 oop java_lang_ClassLoader::parent(oop loader) { 2695 assert(loader->is_oop(), "loader must be oop"); 2696 return loader->obj_field(parent_offset); 2697 } 2698 2699 2700 bool java_lang_ClassLoader::is_trusted_loader(oop loader) { 2701 // Fix for 4474172; see evaluation for more details 2702 loader = non_reflection_class_loader(loader); 2703 2704 oop cl = SystemDictionary::java_system_loader(); 2705 while(cl != NULL) { 2706 if (cl == loader) return true; 2707 cl = parent(cl); 2708 } 2709 return false; 2710 } 2711 2712 oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) { 2713 if (loader != NULL) { 2714 // See whether this is one of the class loaders associated with 2715 // the generated bytecodes for reflection, and if so, "magically" 2716 // delegate to its parent to prevent class loading from occurring 2717 // in places where applications using reflection didn't expect it. 2718 klassOop delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass(); 2719 // This might be null in non-1.4 JDKs 2720 if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) { 2721 return parent(loader); 2722 } 2723 } 2724 return loader; 2725 } 2726 2727 2728 // Support for java_lang_System 2729 int java_lang_System::in_offset_in_bytes() { 2730 return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset); 2731 } 2732 2733 2734 int java_lang_System::out_offset_in_bytes() { 2735 return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset); 2736 } 2737 2738 2739 int java_lang_System::err_offset_in_bytes() { 2740 return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset); 2741 } 2742 2743 2744 2745 int java_lang_String::value_offset; 2746 int java_lang_String::offset_offset; 2747 int java_lang_String::count_offset; 2748 int java_lang_String::hash_offset; 2749 int java_lang_Class::klass_offset; 2750 int java_lang_Class::array_klass_offset; 2751 int java_lang_Class::resolved_constructor_offset; 2752 int java_lang_Class::number_of_fake_oop_fields; 2753 int java_lang_Class::oop_size_offset; 2754 int java_lang_Class::static_oop_field_count_offset; 2755 int java_lang_Throwable::backtrace_offset; 2756 int java_lang_Throwable::detailMessage_offset; 2757 int java_lang_Throwable::cause_offset; 2758 int java_lang_Throwable::stackTrace_offset; 2759 int java_lang_reflect_AccessibleObject::override_offset; 2760 int java_lang_reflect_Method::clazz_offset; 2761 int java_lang_reflect_Method::name_offset; 2762 int java_lang_reflect_Method::returnType_offset; 2763 int java_lang_reflect_Method::parameterTypes_offset; 2764 int java_lang_reflect_Method::exceptionTypes_offset; 2765 int java_lang_reflect_Method::slot_offset; 2766 int java_lang_reflect_Method::modifiers_offset; 2767 int java_lang_reflect_Method::signature_offset; 2768 int java_lang_reflect_Method::annotations_offset; 2769 int java_lang_reflect_Method::parameter_annotations_offset; 2770 int java_lang_reflect_Method::annotation_default_offset; 2771 int java_lang_reflect_Constructor::clazz_offset; 2772 int java_lang_reflect_Constructor::parameterTypes_offset; 2773 int java_lang_reflect_Constructor::exceptionTypes_offset; 2774 int java_lang_reflect_Constructor::slot_offset; 2775 int java_lang_reflect_Constructor::modifiers_offset; 2776 int java_lang_reflect_Constructor::signature_offset; 2777 int java_lang_reflect_Constructor::annotations_offset; 2778 int java_lang_reflect_Constructor::parameter_annotations_offset; 2779 int java_lang_reflect_Field::clazz_offset; 2780 int java_lang_reflect_Field::name_offset; 2781 int java_lang_reflect_Field::type_offset; 2782 int java_lang_reflect_Field::slot_offset; 2783 int java_lang_reflect_Field::modifiers_offset; 2784 int java_lang_reflect_Field::signature_offset; 2785 int java_lang_reflect_Field::annotations_offset; 2786 int java_lang_boxing_object::value_offset; 2787 int java_lang_boxing_object::long_value_offset; 2788 int java_lang_ref_Reference::referent_offset; 2789 int java_lang_ref_Reference::queue_offset; 2790 int java_lang_ref_Reference::next_offset; 2791 int java_lang_ref_Reference::discovered_offset; 2792 int java_lang_ref_Reference::static_lock_offset; 2793 int java_lang_ref_Reference::static_pending_offset; 2794 int java_lang_ref_Reference::number_of_fake_oop_fields; 2795 int java_lang_ref_SoftReference::timestamp_offset; 2796 int java_lang_ref_SoftReference::static_clock_offset; 2797 int java_lang_ClassLoader::parent_offset; 2798 int java_lang_System::static_in_offset; 2799 int java_lang_System::static_out_offset; 2800 int java_lang_System::static_err_offset; 2801 int java_lang_StackTraceElement::declaringClass_offset; 2802 int java_lang_StackTraceElement::methodName_offset; 2803 int java_lang_StackTraceElement::fileName_offset; 2804 int java_lang_StackTraceElement::lineNumber_offset; 2805 int java_lang_AssertionStatusDirectives::classes_offset; 2806 int java_lang_AssertionStatusDirectives::classEnabled_offset; 2807 int java_lang_AssertionStatusDirectives::packages_offset; 2808 int java_lang_AssertionStatusDirectives::packageEnabled_offset; 2809 int java_lang_AssertionStatusDirectives::deflt_offset; 2810 int java_nio_Buffer::_limit_offset; 2811 int sun_misc_AtomicLongCSImpl::_value_offset; 2812 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0; 2813 int sun_reflect_ConstantPool::_cp_oop_offset; 2814 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset; 2815 2816 2817 // Support for java_lang_StackTraceElement 2818 2819 void java_lang_StackTraceElement::set_fileName(oop element, oop value) { 2820 element->obj_field_put(fileName_offset, value); 2821 } 2822 2823 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) { 2824 element->obj_field_put(declaringClass_offset, value); 2825 } 2826 2827 void java_lang_StackTraceElement::set_methodName(oop element, oop value) { 2828 element->obj_field_put(methodName_offset, value); 2829 } 2830 2831 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) { 2832 element->int_field_put(lineNumber_offset, value); 2833 } 2834 2835 2836 // Support for java Assertions - java_lang_AssertionStatusDirectives. 2837 2838 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) { 2839 o->obj_field_put(classes_offset, val); 2840 } 2841 2842 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) { 2843 o->obj_field_put(classEnabled_offset, val); 2844 } 2845 2846 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) { 2847 o->obj_field_put(packages_offset, val); 2848 } 2849 2850 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) { 2851 o->obj_field_put(packageEnabled_offset, val); 2852 } 2853 2854 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) { 2855 o->bool_field_put(deflt_offset, val); 2856 } 2857 2858 2859 // Support for intrinsification of java.nio.Buffer.checkIndex 2860 int java_nio_Buffer::limit_offset() { 2861 return _limit_offset; 2862 } 2863 2864 2865 void java_nio_Buffer::compute_offsets() { 2866 klassOop k = SystemDictionary::java_nio_Buffer_klass(); 2867 assert(k != NULL, "must be loaded in 1.4+"); 2868 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); 2869 } 2870 2871 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate 2872 int sun_misc_AtomicLongCSImpl::value_offset() { 2873 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this"); 2874 return _value_offset; 2875 } 2876 2877 2878 void sun_misc_AtomicLongCSImpl::compute_offsets() { 2879 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass(); 2880 // If this class is not present, its value field offset won't be referenced. 2881 if (k != NULL) { 2882 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature()); 2883 } 2884 } 2885 2886 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { 2887 if (_owner_offset != 0) return; 2888 2889 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); 2890 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); 2891 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass(); 2892 compute_offset(_owner_offset, k, 2893 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); 2894 } 2895 2896 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { 2897 assert(_owner_offset != 0, "Must be initialized"); 2898 return obj->obj_field(_owner_offset); 2899 } 2900 2901 // Compute hard-coded offsets 2902 // Invoked before SystemDictionary::initialize, so pre-loaded classes 2903 // are not available to determine the offset_of_static_fields. 2904 void JavaClasses::compute_hard_coded_offsets() { 2905 const int x = heapOopSize; 2906 const int header = instanceOopDesc::base_offset_in_bytes(); 2907 2908 // Do the String Class 2909 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header; 2910 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header; 2911 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint); 2912 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint); 2913 2914 { 2915 // Do the Class Class 2916 int offset = header; 2917 java_lang_Class::oop_size_offset = header; 2918 offset += BytesPerInt; 2919 java_lang_Class::static_oop_field_count_offset = offset; 2920 offset = align_size_up(offset + BytesPerInt, x); 2921 java_lang_Class::klass_offset = offset; 2922 offset += x; 2923 java_lang_Class::array_klass_offset = offset; 2924 offset += x; 2925 java_lang_Class::resolved_constructor_offset = offset; 2926 } 2927 2928 // This is NOT an offset 2929 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields; 2930 2931 // Throwable Class 2932 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header; 2933 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header; 2934 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header; 2935 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header; 2936 2937 // java_lang_boxing_object 2938 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header; 2939 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong); 2940 2941 // java_lang_ref_Reference: 2942 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header; 2943 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header; 2944 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header; 2945 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header; 2946 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x; 2947 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x; 2948 // Artificial fields for java_lang_ref_Reference 2949 // The first field is for the discovered field added in 1.4 2950 java_lang_ref_Reference::number_of_fake_oop_fields = 1; 2951 2952 // java_lang_ref_SoftReference Class 2953 java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong); 2954 // Don't multiply static fields because they are always in wordSize units 2955 java_lang_ref_SoftReference::static_clock_offset = java_lang_ref_SoftReference::hc_static_clock_offset * x; 2956 2957 // java_lang_ClassLoader 2958 java_lang_ClassLoader::parent_offset = java_lang_ClassLoader::hc_parent_offset * x + header; 2959 2960 // java_lang_System 2961 java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x; 2962 java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x; 2963 java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x; 2964 2965 // java_lang_StackTraceElement 2966 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header; 2967 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header; 2968 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header; 2969 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header; 2970 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header; 2971 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header; 2972 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header; 2973 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header; 2974 java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header; 2975 2976 } 2977 2978 2979 // Compute non-hard-coded field offsets of all the classes in this file 2980 void JavaClasses::compute_offsets() { 2981 2982 java_lang_Class::compute_offsets(); 2983 java_lang_Thread::compute_offsets(); 2984 java_lang_ThreadGroup::compute_offsets(); 2985 if (EnableInvokeDynamic) { 2986 java_lang_invoke_MethodHandle::compute_offsets(); 2987 java_lang_invoke_MemberName::compute_offsets(); 2988 java_lang_invoke_DirectMethodHandle::compute_offsets(); 2989 java_lang_invoke_BoundMethodHandle::compute_offsets(); 2990 java_lang_invoke_AdapterMethodHandle::compute_offsets(); 2991 java_lang_invoke_MethodType::compute_offsets(); 2992 java_lang_invoke_MethodTypeForm::compute_offsets(); 2993 java_lang_invoke_CallSite::compute_offsets(); 2994 } 2995 java_security_AccessControlContext::compute_offsets(); 2996 // Initialize reflection classes. The layouts of these classes 2997 // changed with the new reflection implementation in JDK 1.4, and 2998 // since the Universe doesn't know what JDK version it is until this 2999 // point we defer computation of these offsets until now. 3000 java_lang_reflect_AccessibleObject::compute_offsets(); 3001 java_lang_reflect_Method::compute_offsets(); 3002 java_lang_reflect_Constructor::compute_offsets(); 3003 java_lang_reflect_Field::compute_offsets(); 3004 if (JDK_Version::is_gte_jdk14x_version()) { 3005 java_nio_Buffer::compute_offsets(); 3006 } 3007 if (JDK_Version::is_gte_jdk15x_version()) { 3008 sun_reflect_ConstantPool::compute_offsets(); 3009 sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets(); 3010 } 3011 sun_misc_AtomicLongCSImpl::compute_offsets(); 3012 3013 // generated interpreter code wants to know about the offsets we just computed: 3014 AbstractAssembler::update_delayed_values(); 3015 } 3016 3017 #ifndef PRODUCT 3018 3019 // These functions exist to assert the validity of hard-coded field offsets to guard 3020 // against changes in the class files 3021 3022 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { 3023 EXCEPTION_MARK; 3024 fieldDescriptor fd; 3025 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); 3026 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 3027 instanceKlassHandle h_klass (THREAD, k); 3028 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); 3029 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); 3030 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { 3031 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name); 3032 return false; 3033 } 3034 if (fd.is_static()) { 3035 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name); 3036 return false; 3037 } 3038 if (fd.offset() == hardcoded_offset ) { 3039 return true; 3040 } else { 3041 tty->print_cr("Offset of nonstatic field %s.%s is hardcoded as %d but should really be %d.", 3042 klass_name, field_name, hardcoded_offset, fd.offset()); 3043 return false; 3044 } 3045 } 3046 3047 3048 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { 3049 EXCEPTION_MARK; 3050 fieldDescriptor fd; 3051 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); 3052 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 3053 instanceKlassHandle h_klass (THREAD, k); 3054 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); 3055 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); 3056 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { 3057 tty->print_cr("Static field %s.%s not found", klass_name, field_name); 3058 return false; 3059 } 3060 if (!fd.is_static()) { 3061 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name); 3062 return false; 3063 } 3064 if (fd.offset() == hardcoded_offset + instanceMirrorKlass::offset_of_static_fields()) { 3065 return true; 3066 } else { 3067 tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - instanceMirrorKlass::offset_of_static_fields()); 3068 return false; 3069 } 3070 } 3071 3072 3073 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { 3074 EXCEPTION_MARK; 3075 fieldDescriptor fd; 3076 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); 3077 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 3078 instanceKlassHandle h_klass (THREAD, k); 3079 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); 3080 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); 3081 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { 3082 tty->print_cr("Static field %s.%s not found", klass_name, field_name); 3083 return false; 3084 } 3085 if (!fd.is_static() || !fd.has_initial_value()) { 3086 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name); 3087 return false; 3088 } 3089 if (!fd.initial_value_tag().is_int()) { 3090 tty->print_cr("Static field %s.%s is not an int", klass_name, field_name); 3091 return false; 3092 } 3093 jint field_value = fd.int_initial_value(); 3094 if (field_value == hardcoded_constant) { 3095 return true; 3096 } else { 3097 tty->print_cr("Constant value of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_constant, field_value); 3098 return false; 3099 } 3100 } 3101 3102 3103 // Check the hard-coded field offsets of all the classes in this file 3104 3105 void JavaClasses::check_offsets() { 3106 bool valid = true; 3107 3108 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ 3109 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) 3110 3111 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ 3112 valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig) 3113 3114 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ 3115 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig) 3116 3117 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \ 3118 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig) 3119 3120 // java.lang.String 3121 3122 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C"); 3123 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I"); 3124 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I"); 3125 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I"); 3126 3127 // java.lang.Class 3128 3129 // Fake fields 3130 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked 3131 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked 3132 // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked 3133 3134 // java.lang.Throwable 3135 3136 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;"); 3137 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;"); 3138 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;"); 3139 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;"); 3140 3141 // Boxed primitive objects (java_lang_boxing_object) 3142 3143 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z"); 3144 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C"); 3145 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F"); 3146 CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D"); 3147 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B"); 3148 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S"); 3149 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I"); 3150 CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J"); 3151 3152 // java.lang.ClassLoader 3153 3154 CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;"); 3155 3156 // java.lang.System 3157 3158 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;"); 3159 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;"); 3160 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, err, "Ljava/io/PrintStream;"); 3161 3162 // java.lang.StackTraceElement 3163 3164 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, declaringClass, "Ljava/lang/String;"); 3165 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, methodName, "Ljava/lang/String;"); 3166 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, fileName, "Ljava/lang/String;"); 3167 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, lineNumber, "I"); 3168 3169 // java.lang.ref.Reference 3170 3171 CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, referent, "Ljava/lang/Object;"); 3172 CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, queue, "Ljava/lang/ref/ReferenceQueue;"); 3173 CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, next, "Ljava/lang/ref/Reference;"); 3174 // Fake field 3175 //CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, discovered, "Ljava/lang/ref/Reference;"); 3176 CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, lock, "Ljava/lang/ref/Reference$Lock;"); 3177 CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, pending, "Ljava/lang/ref/Reference;"); 3178 3179 // java.lang.ref.SoftReference 3180 3181 CHECK_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, timestamp, "J"); 3182 CHECK_STATIC_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, clock, "J"); 3183 3184 // java.lang.AssertionStatusDirectives 3185 // 3186 // The CheckAssertionStatusDirectives boolean can be removed from here and 3187 // globals.hpp after the AssertionStatusDirectives class has been integrated 3188 // into merlin "for some time." Without it, the vm will fail with early 3189 // merlin builds. 3190 3191 if (CheckAssertionStatusDirectives && JDK_Version::is_gte_jdk14x_version()) { 3192 const char* nm = "java/lang/AssertionStatusDirectives"; 3193 const char* sig = "[Ljava/lang/String;"; 3194 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classes, sig); 3195 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classEnabled, "[Z"); 3196 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packages, sig); 3197 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packageEnabled, "[Z"); 3198 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, deflt, "Z"); 3199 } 3200 3201 if (!valid) vm_exit_during_initialization("Hard-coded field offset verification failed"); 3202 } 3203 3204 #endif // PRODUCT 3205 3206 void javaClasses_init() { 3207 JavaClasses::compute_offsets(); 3208 JavaClasses::check_offsets(); 3209 FilteredFieldsMap::initialize(); // must be done after computing offsets. 3210 }