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