javaClasses.cpp revision 4802:f2110083203d
150276Speter/* 2178866Srafan * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. 350276Speter * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 450276Speter * 550276Speter * This code is free software; you can redistribute it and/or modify it 650276Speter * under the terms of the GNU General Public License version 2 only, as 750276Speter * published by the Free Software Foundation. 850276Speter * 950276Speter * This code is distributed in the hope that it will be useful, but WITHOUT 1050276Speter * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1150276Speter * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1250276Speter * version 2 for more details (a copy is included in the LICENSE file that 1350276Speter * accompanied this code). 1450276Speter * 1550276Speter * You should have received a copy of the GNU General Public License version 1650276Speter * 2 along with this work; if not, write to the Free Software Foundation, 1750276Speter * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1850276Speter * 1950276Speter * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2050276Speter * or visit www.oracle.com if you need additional information or have any 2150276Speter * questions. 2250276Speter * 2350276Speter */ 2450276Speter 2550276Speter#include "precompiled.hpp" 2650276Speter#include "classfile/altHashing.hpp" 2750276Speter#include "classfile/javaClasses.hpp" 2850276Speter#include "classfile/symbolTable.hpp" 29166124Srafan#include "classfile/vmSymbols.hpp" 3050276Speter#include "code/debugInfo.hpp" 31184989Srafan#include "code/pcDesc.hpp" 3250276Speter#include "compiler/compilerOracle.hpp" 3350276Speter#include "interpreter/interpreter.hpp" 34166124Srafan#include "memory/oopFactory.hpp" 35166124Srafan#include "memory/resourceArea.hpp" 36166124Srafan#include "memory/universe.inline.hpp" 3766963Speter#include "oops/fieldStreams.hpp" 38166124Srafan#include "oops/instanceKlass.hpp" 39166124Srafan#include "oops/instanceMirrorKlass.hpp" 4050276Speter#include "oops/klass.hpp" 4150276Speter#include "oops/method.hpp" 42166124Srafan#include "oops/symbol.hpp" 43166124Srafan#include "oops/typeArrayOop.hpp" 44166124Srafan#include "runtime/fieldDescriptor.hpp" 45166124Srafan#include "runtime/handles.inline.hpp" 46166124Srafan#include "runtime/interfaceSupport.hpp" 47166124Srafan#include "runtime/java.hpp" 48166124Srafan#include "runtime/javaCalls.hpp" 49166124Srafan#include "runtime/safepoint.hpp" 50166124Srafan#include "runtime/thread.inline.hpp" 51166124Srafan#include "runtime/vframe.hpp" 52166124Srafan#include "utilities/preserveException.hpp" 53166124Srafan 54166124Srafan#define INJECTED_FIELD_COMPUTE_OFFSET(klass, name, signature, may_be_java) \ 55166124Srafan klass::_##name##_offset = JavaClasses::compute_injected_offset(JavaClasses::klass##_##name##_enum); 56166124Srafan 57166124Srafan#define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java) \ 58166124Srafan { SystemDictionary::WK_KLASS_ENUM_NAME(klass), vmSymbols::VM_SYMBOL_ENUM_NAME(name##_name), vmSymbols::VM_SYMBOL_ENUM_NAME(signature), may_be_java }, 59166124Srafan 60166124SrafanInjectedField JavaClasses::_injected_fields[] = { 61166124Srafan ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD) 62166124Srafan}; 63166124Srafan 64166124Srafanint JavaClasses::compute_injected_offset(InjectedFieldID id) { 65166124Srafan return _injected_fields[id].compute_offset(); 66166124Srafan} 6750276Speter 6850276Speter 6950276SpeterInjectedField* JavaClasses::get_injected(Symbol* class_name, int* field_count) { 7050276Speter *field_count = 0; 71166124Srafan 7250276Speter vmSymbols::SID sid = vmSymbols::find_sid(class_name); 73166124Srafan if (sid == vmSymbols::NO_SID) { 7450276Speter // Only well known classes can inject fields 7566963Speter return NULL; 76166124Srafan } 7750276Speter 7850276Speter int count = 0; 7950276Speter int start = -1; 80166124Srafan 8150276Speter#define LOOKUP_INJECTED_FIELD(klass, name, signature, may_be_java) \ 8250276Speter if (sid == vmSymbols::VM_SYMBOL_ENUM_NAME(klass)) { \ 83166124Srafan count++; \ 8450276Speter if (start == -1) start = klass##_##name##_enum; \ 8550276Speter } 8650276Speter ALL_INJECTED_FIELDS(LOOKUP_INJECTED_FIELD); 8750276Speter#undef LOOKUP_INJECTED_FIELD 8850276Speter 89166124Srafan if (start != -1) { 90166124Srafan *field_count = count; 9176726Speter return _injected_fields + start; 9297049Speter } 93166124Srafan return NULL; 94166124Srafan} 95166124Srafan 96166124Srafan 9776726Speterstatic bool find_field(InstanceKlass* ik, 9876726Speter Symbol* name_symbol, Symbol* signature_symbol, 99166124Srafan fieldDescriptor* fd, 10097049Speter bool allow_super = false) { 10197049Speter if (allow_super) 102166124Srafan return ik->find_field(name_symbol, signature_symbol, fd) != NULL; 103166124Srafan else 10476726Speter return ik->find_local_field(name_symbol, signature_symbol, fd); 10576726Speter} 106166124Srafan 107166124Srafan// Helpful routine for computing field offsets at run time rather than hardcoding them 10876726Speterstatic void 10976726Spetercompute_offset(int &dest_offset, 110166124Srafan Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol, 111166124Srafan bool allow_super = false) { 112166124Srafan fieldDescriptor fd; 113166124Srafan InstanceKlass* ik = InstanceKlass::cast(klass_oop); 114166124Srafan if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { 115166124Srafan ResourceMark rm; 116166124Srafan tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); 117166124Srafan#ifndef PRODUCT 118166124Srafan klass_oop->print(); 119166124Srafan tty->print_cr("all fields:"); 120166124Srafan for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { 121166124Srafan tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); 122166124Srafan } 123166124Srafan#endif //PRODUCT 124166124Srafan fatal("Invalid layout of preloaded class"); 125166124Srafan } 126166124Srafan dest_offset = fd.offset(); 12776726Speter} 12897049Speter 12976726Speter// Same as above but for "optional" offsets that might not be present in certain JDK versions 13097049Speterstatic void 13197049Spetercompute_optional_offset(int& dest_offset, 13276726Speter Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol, 13376726Speter bool allow_super = false) { 13476726Speter fieldDescriptor fd; 13576726Speter InstanceKlass* ik = InstanceKlass::cast(klass_oop); 13697049Speter if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { 13776726Speter dest_offset = fd.offset(); 13876726Speter } 139166124Srafan} 140166124Srafan 141166124Srafan 142166124Srafanint java_lang_String::value_offset = 0; 143166124Srafanint java_lang_String::offset_offset = 0; 144166124Srafanint java_lang_String::count_offset = 0; 145166124Srafanint java_lang_String::hash_offset = 0; 146166124Srafan 147166124Srafanbool java_lang_String::initialized = false; 148166124Srafan 149166124Srafanvoid java_lang_String::compute_offsets() { 15076726Speter assert(!initialized, "offsets should be initialized only once"); 15197049Speter 15297049Speter Klass* k = SystemDictionary::String_klass(); 15397049Speter compute_offset(value_offset, k, vmSymbols::value_name(), vmSymbols::char_array_signature()); 15497049Speter compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature()); 15597049Speter compute_optional_offset(count_offset, k, vmSymbols::count_name(), vmSymbols::int_signature()); 15697049Speter compute_optional_offset(hash_offset, k, vmSymbols::hash_name(), vmSymbols::int_signature()); 15797049Speter 15897049Speter initialized = true; 159166124Srafan} 16097049Speter 16197049SpeterHandle java_lang_String::basic_create(int length, TRAPS) { 162166124Srafan assert(initialized, "Must be initialized"); 163166124Srafan // Create the String object first, so there's a chance that the String 164166124Srafan // and the char array it points to end up in the same cache line. 165166124Srafan oop obj; 166166124Srafan obj = InstanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH); 167166124Srafan 168166124Srafan // Create the char array. The String object must be handlized here 16976726Speter // because GC can happen as a result of the allocation attempt. 17076726Speter Handle h_obj(THREAD, obj); 171178866Srafan typeArrayOop buffer; 172174993Srafan buffer = oopFactory::new_charArray(length, CHECK_NH); 173174993Srafan 174174993Srafan // Point the String at the char array 175174993Srafan obj = h_obj(); 176174993Srafan set_value(obj, buffer); 177174993Srafan // No need to zero the offset, allocation zero'ed the entire String object 178174993Srafan assert(offset(obj) == 0, "initial String offset should be zero"); 179174993Srafan//set_offset(obj, 0); 180174993Srafan set_count(obj, length); 181174993Srafan 182174993Srafan return h_obj; 183174993Srafan} 184174993Srafan 185174993SrafanHandle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { 186174993Srafan Handle h_obj = basic_create(length, CHECK_NH); 187174993Srafan typeArrayOop buffer = value(h_obj()); 188174993Srafan for (int index = 0; index < length; index++) { 189174993Srafan buffer->char_at_put(index, unicode[index]); 190174993Srafan } 191174993Srafan return h_obj; 192174993Srafan} 193174993Srafan 194174993Srafanoop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) { 195174993Srafan Handle h_obj = create_from_unicode(unicode, length, CHECK_0); 196174993Srafan return h_obj(); 197174993Srafan} 198174993Srafan 199174993SrafanHandle java_lang_String::create_from_str(const char* utf8_str, TRAPS) { 200174993Srafan if (utf8_str == NULL) { 201174993Srafan return Handle(); 202174993Srafan } 203174993Srafan int length = UTF8::unicode_length(utf8_str); 204174993Srafan Handle h_obj = basic_create(length, CHECK_NH); 205174993Srafan if (length > 0) { 206174993Srafan UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length); 207174993Srafan } 208174993Srafan return h_obj; 209174993Srafan} 210174993Srafan 211174993Srafanoop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) { 212174993Srafan Handle h_obj = create_from_str(utf8_str, CHECK_0); 213178866Srafan return h_obj(); 214174993Srafan} 215174993Srafan 216174993SrafanHandle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) { 217174993Srafan int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); 218174993Srafan Handle h_obj = basic_create(length, CHECK_NH); 219174993Srafan if (length > 0) { 220174993Srafan UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); 221174993Srafan } 222174993Srafan return h_obj; 223174993Srafan} 224174993Srafan 225174993Srafan// Converts a C string to a Java String based on current encoding 226174993SrafanHandle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) { 227174993Srafan assert(str != NULL, "bad arguments"); 228178866Srafan 229174993Srafan typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *); 230174993Srafan static to_java_string_fn_t _to_java_string_fn = NULL; 231174993Srafan 232174993Srafan if (_to_java_string_fn == NULL) { 233174993Srafan void *lib_handle = os::native_java_library(); 234174993Srafan _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, os::dll_lookup(lib_handle, "NewStringPlatform")); 235174993Srafan if (_to_java_string_fn == NULL) { 236174993Srafan fatal("NewStringPlatform missing"); 237174993Srafan } 238174993Srafan } 239174993Srafan 240174993Srafan jstring js = NULL; 241174993Srafan { JavaThread* thread = (JavaThread*)THREAD; 242174993Srafan assert(thread->is_Java_thread(), "must be java thread"); 243174993Srafan HandleMark hm(thread); 244174993Srafan ThreadToNativeFromVM ttn(thread); 245174993Srafan js = (_to_java_string_fn)(thread->jni_environment(), str); 246174993Srafan } 247174993Srafan return Handle(THREAD, JNIHandles::resolve(js)); 248174993Srafan} 249174993Srafan 250174993Srafan// Converts a Java String to a native C string that can be used for 251174993Srafan// native OS calls. 252174993Srafanchar* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) { 253174993Srafan 254174993Srafan typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*); 255174993Srafan static to_platform_string_fn_t _to_platform_string_fn = NULL; 256178866Srafan 257174993Srafan if (_to_platform_string_fn == NULL) { 258174993Srafan void *lib_handle = os::native_java_library(); 259174993Srafan _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, os::dll_lookup(lib_handle, "GetStringPlatformChars")); 260174993Srafan if (_to_platform_string_fn == NULL) { 261174993Srafan fatal("GetStringPlatformChars missing"); 262174993Srafan } 263174993Srafan } 264184989Srafan 265184989Srafan char *native_platform_string; 266184989Srafan { JavaThread* thread = (JavaThread*)THREAD; 267184989Srafan assert(thread->is_Java_thread(), "must be java thread"); 268184989Srafan JNIEnv *env = thread->jni_environment(); 269184989Srafan jstring js = (jstring) JNIHandles::make_local(env, java_string()); 270184989Srafan bool is_copy; 271184989Srafan HandleMark hm(thread); 272184989Srafan ThreadToNativeFromVM ttn(thread); 273184989Srafan native_platform_string = (_to_platform_string_fn)(env, js, &is_copy); 274184989Srafan assert(is_copy == JNI_TRUE, "is_copy value changed"); 275184989Srafan JNIHandles::destroy_local(js); 276184989Srafan } 277184989Srafan return native_platform_string; 278184989Srafan} 279184989Srafan 280184989SrafanHandle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) { 281184989Srafan oop obj = java_string(); 282184989Srafan // Typical usage is to convert all '/' to '.' in string. 283184989Srafan typeArrayOop value = java_lang_String::value(obj); 284184989Srafan int offset = java_lang_String::offset(obj); 285184989Srafan int length = java_lang_String::length(obj); 286166124Srafan 287166124Srafan // First check if any from_char exist 28850276Speter int index; // Declared outside, used later 28950276Speter for (index = 0; index < length; index++) { 29050276Speter if (value->char_at(index + offset) == from_char) { 29150276Speter break; 29297049Speter } 29350276Speter } 29450276Speter if (index == length) { 29576726Speter // No from_char, so do not copy. 29650276Speter return java_string; 29750276Speter } 29850276Speter 29950276Speter // Create new UNICODE buffer. Must handlize value because GC 30050276Speter // may happen during String and char array creation. 30150276Speter typeArrayHandle h_value(THREAD, value); 30250276Speter Handle string = basic_create(length, CHECK_NH); 30350276Speter 30450276Speter typeArrayOop from_buffer = h_value(); 30550276Speter typeArrayOop to_buffer = java_lang_String::value(string()); 30650276Speter 30762449Speter // Copy contents 30850276Speter for (index = 0; index < length; index++) { 30950276Speter jchar c = from_buffer->char_at(index + offset); 31050276Speter if (c == from_char) { 31176726Speter c = to_char; 31250276Speter } 31350276Speter to_buffer->char_at_put(index, c); 31450276Speter } 31550276Speter return string; 31650276Speter} 31750276Speter 31850276Speterjchar* java_lang_String::as_unicode_string(oop java_string, int& length, TRAPS) { 31950276Speter typeArrayOop value = java_lang_String::value(java_string); 32050276Speter int offset = java_lang_String::offset(java_string); 32150276Speter length = java_lang_String::length(java_string); 32250276Speter 32350276Speter jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length); 32450276Speter if (result != NULL) { 32550276Speter for (int index = 0; index < length; index++) { 32676726Speter result[index] = value->char_at(index + offset); 32750276Speter } 32850276Speter } else { 32950276Speter THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string"); 33050276Speter } 33176726Speter return result; 33250276Speter} 33350276Speter 33450276Speterunsigned int java_lang_String::hash_code(oop java_string) { 33550276Speter int length = java_lang_String::length(java_string); 33650276Speter // Zero length string will hash to zero with String.hashCode() function. 33750276Speter if (length == 0) return 0; 338178866Srafan 339166124Srafan typeArrayOop value = java_lang_String::value(java_string); 34050276Speter int offset = java_lang_String::offset(java_string); 34150276Speter return java_lang_String::hash_code(value->char_at_addr(offset), length); 34250276Speter} 34350276Speter 34450276Speterchar* java_lang_String::as_quoted_ascii(oop java_string) { 34550276Speter typeArrayOop value = java_lang_String::value(java_string); 34650276Speter int offset = java_lang_String::offset(java_string); 347178866Srafan int length = java_lang_String::length(java_string); 34850276Speter 34950276Speter jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 35050276Speter if (base == NULL) return NULL; 35150276Speter 35250276Speter int result_length = UNICODE::quoted_ascii_length(base, length) + 1; 35350276Speter char* result = NEW_RESOURCE_ARRAY(char, result_length); 35450276Speter UNICODE::as_quoted_ascii(base, length, result, result_length); 35550276Speter assert(result_length >= length + 1, "must not be shorter"); 356184989Srafan assert(result_length == (int)strlen(result) + 1, "must match"); 357184989Srafan return result; 358184989Srafan} 359184989Srafan 360184989Srafanunsigned int java_lang_String::hash_string(oop java_string) { 361184989Srafan int length = java_lang_String::length(java_string); 362184989Srafan // Zero length string doesn't hash necessarily hash to zero. 363184989Srafan if (length == 0) { 364184989Srafan return StringTable::hash_string(NULL, 0); 365184989Srafan } 366184989Srafan 367184989Srafan typeArrayOop value = java_lang_String::value(java_string); 368184989Srafan int offset = java_lang_String::offset(java_string); 369184989Srafan return StringTable::hash_string(value->char_at_addr(offset), length); 370184989Srafan} 371184989Srafan 372184989SrafanSymbol* java_lang_String::as_symbol(Handle java_string, TRAPS) { 373184989Srafan oop obj = java_string(); 374184989Srafan typeArrayOop value = java_lang_String::value(obj); 375184989Srafan int offset = java_lang_String::offset(obj); 376184989Srafan int length = java_lang_String::length(obj); 377184989Srafan jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 378184989Srafan Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD); 379184989Srafan return sym; 380166124Srafan} 381166124Srafan 38250276SpeterSymbol* java_lang_String::as_symbol_or_null(oop java_string) { 38350276Speter typeArrayOop value = java_lang_String::value(java_string); 38450276Speter int offset = java_lang_String::offset(java_string); 38550276Speter int length = java_lang_String::length(java_string); 38650276Speter jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); 38750276Speter return SymbolTable::probe_unicode(base, length); 388166124Srafan} 389166124Srafan 39050276Speter 39150276Speterint java_lang_String::utf8_length(oop java_string) { 392166124Srafan typeArrayOop value = java_lang_String::value(java_string); 393166124Srafan int offset = java_lang_String::offset(java_string); 394166124Srafan int length = java_lang_String::length(java_string); 395166124Srafan jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); 396166124Srafan return UNICODE::utf8_length(position, length); 397166124Srafan} 398166124Srafan 399166124Srafanchar* java_lang_String::as_utf8_string(oop java_string) { 400166124Srafan typeArrayOop value = java_lang_String::value(java_string); 401166124Srafan int offset = java_lang_String::offset(java_string); 402166124Srafan int length = java_lang_String::length(java_string); 403166124Srafan jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); 404166124Srafan return UNICODE::as_utf8(position, length); 405166124Srafan} 406166124Srafan 407166124Srafanchar* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) { 408166124Srafan typeArrayOop value = java_lang_String::value(java_string); 409166124Srafan int offset = java_lang_String::offset(java_string); 41066963Speter int length = java_lang_String::length(java_string); 411166124Srafan jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); 41250276Speter return UNICODE::as_utf8(position, length, buf, buflen); 41350276Speter} 41450276Speter 41550276Speterchar* java_lang_String::as_utf8_string(oop java_string, int start, int len) { 41650276Speter typeArrayOop value = java_lang_String::value(java_string); 41750276Speter int offset = java_lang_String::offset(java_string); 41850276Speter int length = java_lang_String::length(java_string); 41950276Speter assert(start + len <= length, "just checking"); 420166124Srafan jchar* position = value->char_at_addr(offset + start); 42166963Speter return UNICODE::as_utf8(position, len); 42250276Speter} 42350276Speter 42450276Speterbool java_lang_String::equals(oop java_string, jchar* chars, int len) { 42550276Speter assert(java_string->klass() == SystemDictionary::String_klass(), 42650276Speter "must be java_string"); 427166124Srafan typeArrayOop value = java_lang_String::value(java_string); 428166124Srafan int offset = java_lang_String::offset(java_string); 42950276Speter int length = java_lang_String::length(java_string); 43050276Speter if (length != len) { 43197049Speter return false; 43297049Speter } 43397049Speter for (int i = 0; i < len; i++) { 43450276Speter if (value->char_at(i + offset) != chars[i]) { 43550276Speter return false; 43666963Speter } 43750276Speter } 43850276Speter return true; 43950276Speter} 44050276Speter 44150276Spetervoid java_lang_String::print(Handle java_string, outputStream* st) { 44297049Speter oop obj = java_string(); 44397049Speter assert(obj->klass() == SystemDictionary::String_klass(), "must be java_string"); 44497049Speter typeArrayOop value = java_lang_String::value(obj); 44566963Speter int offset = java_lang_String::offset(obj); 44656639Speter int length = java_lang_String::length(obj); 44756639Speter 44856639Speter int end = MIN2(length, 100); 44956639Speter if (value == NULL) { 45050276Speter // This can happen if, e.g., printing a String 45150276Speter // object before its initializer has been called 45297049Speter st->print_cr("NULL"); 45397049Speter } else { 45497049Speter st->print("\""); 45597049Speter for (int index = 0; index < length; index++) { 45697049Speter st->print("%c", value->char_at(index + offset)); 45797049Speter } 45897049Speter st->print("\""); 45997049Speter } 46097049Speter} 46150276Speter 46250276Speterstatic void initialize_static_field(fieldDescriptor* fd, TRAPS) { 46350276Speter Handle mirror (THREAD, fd->field_holder()->java_mirror()); 46450276Speter assert(mirror.not_null() && fd->is_static(), "just checking"); 46550276Speter if (fd->has_initial_value()) { 46650276Speter BasicType t = fd->field_type(); 46750276Speter switch (t) { 46850276Speter case T_BYTE: 46950276Speter mirror()->byte_field_put(fd->offset(), fd->int_initial_value()); 47050276Speter break; 47150276Speter case T_BOOLEAN: 47250276Speter mirror()->bool_field_put(fd->offset(), fd->int_initial_value()); 47350276Speter break; 474166124Srafan case T_CHAR: 47550276Speter mirror()->char_field_put(fd->offset(), fd->int_initial_value()); 47650276Speter break; 47797049Speter case T_SHORT: 47897049Speter mirror()->short_field_put(fd->offset(), fd->int_initial_value()); 47997049Speter break; 48097049Speter case T_INT: 48150276Speter mirror()->int_field_put(fd->offset(), fd->int_initial_value()); 48250276Speter break; 48350276Speter case T_FLOAT: 48450276Speter mirror()->float_field_put(fd->offset(), fd->float_initial_value()); 48550276Speter break; 48650276Speter case T_DOUBLE: 48797049Speter mirror()->double_field_put(fd->offset(), fd->double_initial_value()); 48897049Speter break; 48997049Speter case T_LONG: 49097049Speter mirror()->long_field_put(fd->offset(), fd->long_initial_value()); 49197049Speter break; 49250276Speter case T_OBJECT: 49350276Speter { 49450276Speter #ifdef ASSERT 495166124Srafan TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK); 496166124Srafan assert(fd->signature() == sym, "just checking"); 497166124Srafan #endif 498166124Srafan oop string = fd->string_initial_value(CHECK); 499166124Srafan mirror()->obj_field_put(fd->offset(), string); 500166124Srafan } 501166124Srafan break; 502166124Srafan default: 503166124Srafan THROW_MSG(vmSymbols::java_lang_ClassFormatError(), 504166124Srafan "Illegal ConstantValue attribute in class file"); 505166124Srafan } 506166124Srafan } 507166124Srafan} 508166124Srafan 509166124Srafan 510166124Srafanvoid java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) { 511166124Srafan assert(InstanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); 512166124Srafan 513166124Srafan // If the offset was read from the shared archive, it was fixed up already 514166124Srafan if (!k->is_shared()) { 515166124Srafan if (k->oop_is_instance()) { 516166124Srafan // During bootstrap, java.lang.Class wasn't loaded so static field 517166124Srafan // offsets were computed without the size added it. Go back and 518166124Srafan // update all the static field offsets to included the size. 519166124Srafan for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) { 520166124Srafan if (fs.access_flags().is_static()) { 521166124Srafan int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields(); 522166124Srafan fs.set_offset(real_offset); 523166124Srafan } 524166124Srafan } 525166124Srafan } 526166124Srafan } 527166124Srafan create_mirror(k, Handle(NULL), CHECK); 528166124Srafan} 529166124Srafan 530166124Srafanoop java_lang_Class::create_mirror(KlassHandle k, Handle protection_domain, TRAPS) { 531166124Srafan assert(k->java_mirror() == NULL, "should only assign mirror once"); 532166124Srafan // Use this moment of initialization to cache modifier_flags also, 533166124Srafan // to support Class.getModifiers(). Instance classes recalculate 534166124Srafan // the cached flags after the class file is parsed, but before the 535166124Srafan // class is put into the system dictionary. 536166124Srafan int computed_modifiers = k->compute_modifier_flags(CHECK_0); 537166124Srafan k->set_modifier_flags(computed_modifiers); 538166124Srafan // Class_klass has to be loaded because it is used to allocate 539166124Srafan // the mirror. 540166124Srafan if (SystemDictionary::Class_klass_loaded()) { 541166124Srafan // Allocate mirror (java.lang.Class instance) 542166124Srafan Handle mirror = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); 543166124Srafan 544166124Srafan InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass()); 545166124Srafan java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror())); 546166124Srafan 547166124Srafan // It might also have a component mirror. This mirror must already exist. 548166124Srafan if (k->oop_is_array()) { 549166124Srafan Handle comp_mirror; 550166124Srafan if (k->oop_is_typeArray()) { 551166124Srafan BasicType type = TypeArrayKlass::cast(k())->element_type(); 552166124Srafan comp_mirror = Universe::java_mirror(type); 553166124Srafan } else { 554166124Srafan assert(k->oop_is_objArray(), "Must be"); 555166124Srafan Klass* element_klass = ObjArrayKlass::cast(k())->element_klass(); 556166124Srafan assert(element_klass != NULL, "Must have an element klass"); 557166124Srafan comp_mirror = element_klass->java_mirror(); 558166124Srafan } 559166124Srafan assert(comp_mirror.not_null(), "must have a mirror"); 560166124Srafan 561166124Srafan // Two-way link between the array klass and its component mirror: 562166124Srafan ArrayKlass::cast(k())->set_component_mirror(comp_mirror()); 563166124Srafan set_array_klass(comp_mirror(), k()); 564166124Srafan } else { 565166124Srafan assert(k->oop_is_instance(), "Must be"); 566166124Srafan 567166124Srafan // Allocate a simple java object for a lock. 568166124Srafan // This needs to be a java object because during class initialization 569166124Srafan // it can be held across a java call. 570166124Srafan typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK_NULL); 571166124Srafan set_init_lock(mirror(), r); 572166124Srafan 573166124Srafan // Set protection domain also 574166124Srafan set_protection_domain(mirror(), protection_domain()); 575166124Srafan 576166124Srafan // Initialize static fields 577166124Srafan InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL); 578166124Srafan } 579166124Srafan return mirror(); 580166124Srafan } else { 581166124Srafan if (fixup_mirror_list() == NULL) { 582166124Srafan GrowableArray<Klass*>* list = 583166124Srafan new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true); 584166124Srafan set_fixup_mirror_list(list); 585166124Srafan } 586166124Srafan fixup_mirror_list()->push(k()); 587166124Srafan return NULL; 58850276Speter } 58950276Speter} 59050276Speter 59150276Speter 59250276Speter 59350276Speterint java_lang_Class::oop_size(oop java_class) { 59450276Speter assert(_oop_size_offset != 0, "must be set"); 59550276Speter return java_class->int_field(_oop_size_offset); 59650276Speter} 59750276Spetervoid java_lang_Class::set_oop_size(oop java_class, int size) { 59850276Speter assert(_oop_size_offset != 0, "must be set"); 59950276Speter java_class->int_field_put(_oop_size_offset, size); 60050276Speter} 60150276Speterint java_lang_Class::static_oop_field_count(oop java_class) { 60250276Speter assert(_static_oop_field_count_offset != 0, "must be set"); 60350276Speter return java_class->int_field(_static_oop_field_count_offset); 604166124Srafan} 60550276Spetervoid java_lang_Class::set_static_oop_field_count(oop java_class, int size) { 60650276Speter assert(_static_oop_field_count_offset != 0, "must be set"); 60750276Speter java_class->int_field_put(_static_oop_field_count_offset, size); 60850276Speter} 60950276Speter 61050276Speteroop java_lang_Class::protection_domain(oop java_class) { 61150276Speter assert(_protection_domain_offset != 0, "must be set"); 61250276Speter return java_class->obj_field(_protection_domain_offset); 61350276Speter} 61450276Spetervoid java_lang_Class::set_protection_domain(oop java_class, oop pd) { 61550276Speter assert(_protection_domain_offset != 0, "must be set"); 61650276Speter java_class->obj_field_put(_protection_domain_offset, pd); 61750276Speter} 61850276Speter 61950276Speteroop java_lang_Class::init_lock(oop java_class) { 62050276Speter assert(_init_lock_offset != 0, "must be set"); 62150276Speter return java_class->obj_field(_init_lock_offset); 62250276Speter} 62350276Spetervoid java_lang_Class::set_init_lock(oop java_class, oop init_lock) { 62450276Speter assert(_init_lock_offset != 0, "must be set"); 62550276Speter java_class->obj_field_put(_init_lock_offset, init_lock); 62650276Speter} 62750276Speter 62850276SpeterobjArrayOop java_lang_Class::signers(oop java_class) { 62950276Speter assert(_signers_offset != 0, "must be set"); 63050276Speter return (objArrayOop)java_class->obj_field(_signers_offset); 63150276Speter} 63250276Spetervoid java_lang_Class::set_signers(oop java_class, objArrayOop signers) { 63350276Speter assert(_signers_offset != 0, "must be set"); 63450276Speter java_class->obj_field_put(_signers_offset, (oop)signers); 63550276Speter} 63650276Speter 63750276Speter 63850276Speteroop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { 63950276Speter // This should be improved by adding a field at the Java level or by 640166124Srafan // introducing a new VM klass (see comment in ClassFileParser) 641166124Srafan oop java_class = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0); 64250276Speter if (type != T_VOID) { 64350276Speter Klass* aklass = Universe::typeArrayKlassObj(type); 64450276Speter assert(aklass != NULL, "correct bootstrap"); 64550276Speter set_array_klass(java_class, aklass); 64650276Speter } 64750276Speter#ifdef ASSERT 64850276Speter InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(SystemDictionary::Class_klass()); 64950276Speter assert(java_lang_Class::static_oop_field_count(java_class) == 0, "should have been zeroed by allocation"); 65050276Speter#endif 65150276Speter return java_class; 65250276Speter} 65350276Speter 65450276Speter 65550276SpeterKlass* java_lang_Class::as_Klass(oop java_class) { 65650276Speter //%note memory_2 65750276Speter assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 65850276Speter Klass* k = ((Klass*)java_class->metadata_field(_klass_offset)); 65950276Speter assert(k == NULL || k->is_klass(), "type check"); 66066963Speter return k; 66150276Speter} 66250276Speter 663178866Srafan 664166124Srafanvoid java_lang_Class::set_klass(oop java_class, Klass* klass) { 66550276Speter assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 66650276Speter java_class->metadata_field_put(_klass_offset, klass); 66750276Speter} 66850276Speter 66966963Speter 67066963Spetervoid java_lang_Class::print_signature(oop java_class, outputStream* st) { 67166963Speter assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 672166124Srafan Symbol* name = NULL; 673166124Srafan bool is_instance = false; 674166124Srafan if (is_primitive(java_class)) { 67550276Speter name = vmSymbols::type_signature(primitive_type(java_class)); 67650276Speter } else { 677166124Srafan Klass* k = as_Klass(java_class); 67866963Speter is_instance = k->oop_is_instance(); 67950276Speter name = k->name(); 68050276Speter } 68150276Speter if (name == NULL) { 68250276Speter st->print("<null>"); 68350276Speter return; 68450276Speter } 68550276Speter if (is_instance) st->print("L"); 68650276Speter st->write((char*) name->base(), (int) name->utf8_length()); 68750276Speter if (is_instance) st->print(";"); 68850276Speter} 68950276Speter 69097049SpeterSymbol* java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) { 69150276Speter assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 69250276Speter Symbol* name; 69350276Speter if (is_primitive(java_class)) { 694178866Srafan name = vmSymbols::type_signature(primitive_type(java_class)); 69550276Speter // Because this can create a new symbol, the caller has to decrement 69650276Speter // the refcount, so make adjustment here and below for symbols returned 69750276Speter // that are not created or incremented due to a successful lookup. 698184989Srafan name->increment_refcount(); 699166124Srafan } else { 70050276Speter Klass* k = as_Klass(java_class); 70150276Speter if (!k->oop_is_instance()) { 70250276Speter name = k->name(); 70350276Speter name->increment_refcount(); 70450276Speter } else { 705184989Srafan ResourceMark rm; 70650276Speter const char* sigstr = k->signature_name(); 70750276Speter int siglen = (int) strlen(sigstr); 70897049Speter if (!intern_if_not_found) { 70950276Speter name = SymbolTable::probe(sigstr, siglen); 71062449Speter } else { 71150276Speter name = SymbolTable::new_symbol(sigstr, siglen, THREAD); 71250276Speter } 71350276Speter } 71450276Speter } 71550276Speter return name; 716184989Srafan} 71797049Speter 71897049Speter 71950276SpeterKlass* java_lang_Class::array_klass(oop java_class) { 72050276Speter Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset)); 72197049Speter assert(k == NULL || k->is_klass() && k->oop_is_array(), "should be array klass"); 72297049Speter return k; 72350276Speter} 72450276Speter 72550276Speter 72650276Spetervoid java_lang_Class::set_array_klass(oop java_class, Klass* klass) { 727184989Srafan assert(klass->is_klass() && klass->oop_is_array(), "should be array klass"); 72850276Speter java_class->metadata_field_put(_array_klass_offset, klass); 72950276Speter} 730166124Srafan 731166124Srafan 73250276Speterbool java_lang_Class::is_primitive(oop java_class) { 73350276Speter // should assert: 73450276Speter //assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 73550276Speter bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL); 73650276Speter 73750276Speter#ifdef ASSERT 73897049Speter if (is_primitive) { 73950276Speter Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset)); 74050276Speter assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()), 74150276Speter "Should be either the T_VOID primitive or a java primitive"); 74250276Speter } 74350276Speter#endif 74497049Speter 74597049Speter return is_primitive; 74697049Speter} 74750276Speter 74897049Speter 74997049SpeterBasicType java_lang_Class::primitive_type(oop java_class) { 75050276Speter assert(java_lang_Class::is_primitive(java_class), "just checking"); 75150276Speter Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset)); 75250276Speter BasicType type = T_VOID; 75350276Speter if (ak != NULL) { 75450276Speter // Note: create_basic_type_mirror above initializes ak to a non-null value. 755174993Srafan type = ArrayKlass::cast(ak)->element_type(); 756174993Srafan } else { 757174993Srafan assert(java_class == Universe::void_mirror(), "only valid non-array primitive"); 758174993Srafan } 759174993Srafan assert(Universe::java_mirror(type) == java_class, "must be consistent"); 760174993Srafan return type; 761174993Srafan} 762174993Srafan 763174993SrafanBasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) { 764174993Srafan assert(java_lang_Class::is_instance(java_class), "must be a Class object"); 765174993Srafan if (is_primitive(java_class)) { 766174993Srafan if (reference_klass != NULL) 767174993Srafan (*reference_klass) = NULL; 768174993Srafan return primitive_type(java_class); 769174993Srafan } else { 770174993Srafan if (reference_klass != NULL) 771174993Srafan (*reference_klass) = as_Klass(java_class); 772174993Srafan return T_OBJECT; 773174993Srafan } 774174993Srafan} 775174993Srafan 776174993Srafan 777174993Srafanoop java_lang_Class::primitive_mirror(BasicType t) { 778174993Srafan oop mirror = Universe::java_mirror(t); 779174993Srafan assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class"); 780174993Srafan assert(java_lang_Class::is_primitive(mirror), "must be primitive"); 781174993Srafan return mirror; 782174993Srafan} 783174993Srafan 784174993Srafanbool java_lang_Class::offsets_computed = false; 785174993Srafanint java_lang_Class::classRedefinedCount_offset = -1; 786174993Srafan 787174993Srafanvoid java_lang_Class::compute_offsets() { 788174993Srafan assert(!offsets_computed, "offsets should be initialized only once"); 789174993Srafan offsets_computed = true; 790174993Srafan 791174993Srafan Klass* klass_oop = SystemDictionary::Class_klass(); 792174993Srafan // The classRedefinedCount field is only present starting in 1.5, 793174993Srafan // so don't go fatal. 794174993Srafan compute_optional_offset(classRedefinedCount_offset, 795174993Srafan klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); 796174993Srafan 797174993Srafan CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); 798174993Srafan} 799166124Srafan 800166124Srafanint java_lang_Class::classRedefinedCount(oop the_class_mirror) { 80156639Speter if (!JDK_Version::is_gte_jdk15x_version() 80256639Speter || classRedefinedCount_offset == -1) { 80356639Speter // The classRedefinedCount field is only present starting in 1.5. 80456639Speter // If we don't have an offset for it then just return -1 as a marker. 80550276Speter return -1; 80676726Speter } 80756639Speter 80876726Speter return the_class_mirror->int_field(classRedefinedCount_offset); 80956639Speter} 81056639Speter 81156639Spetervoid java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) { 81256639Speter if (!JDK_Version::is_gte_jdk15x_version() 81356639Speter || classRedefinedCount_offset == -1) { 81456639Speter // The classRedefinedCount field is only present starting in 1.5. 81556639Speter // If we don't have an offset for it then nothing to set. 81656639Speter return; 81756639Speter } 81856639Speter 81956639Speter the_class_mirror->int_field_put(classRedefinedCount_offset, value); 82056639Speter} 82156639Speter 82256639Speter 82356639Speter// Note: JDK1.1 and before had a privateInfo_offset field which was used for the 82456639Speter// platform thread structure, and a eetop offset which was used for thread 82556639Speter// local storage (and unused by the HotSpot VM). In JDK1.2 the two structures 82656639Speter// merged, so in the HotSpot VM we just use the eetop field for the thread 82756639Speter// instead of the privateInfo_offset. 82876726Speter// 82956639Speter// Note: The stackSize field is only present starting in 1.4. 83050276Speter 83156639Speterint java_lang_Thread::_name_offset = 0; 83250276Speterint java_lang_Thread::_group_offset = 0; 83350276Speterint java_lang_Thread::_contextClassLoader_offset = 0; 834166124Srafanint java_lang_Thread::_inheritedAccessControlContext_offset = 0; 835166124Srafanint java_lang_Thread::_priority_offset = 0; 836166124Srafanint java_lang_Thread::_eetop_offset = 0; 837166124Srafanint java_lang_Thread::_daemon_offset = 0; 838166124Srafanint java_lang_Thread::_stillborn_offset = 0; 839166124Srafanint java_lang_Thread::_stackSize_offset = 0; 840166124Srafanint java_lang_Thread::_tid_offset = 0; 841166124Srafanint java_lang_Thread::_thread_status_offset = 0; 842166124Srafanint java_lang_Thread::_park_blocker_offset = 0; 843166124Srafanint java_lang_Thread::_park_event_offset = 0 ; 844166124Srafan 845166124Srafan 846166124Srafanvoid java_lang_Thread::compute_offsets() { 847166124Srafan assert(_group_offset == 0, "offsets should be initialized only once"); 848166124Srafan 849166124Srafan Klass* k = SystemDictionary::Thread_klass(); 850166124Srafan compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); 851166124Srafan compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); 852166124Srafan compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); 853166124Srafan compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); 854166124Srafan compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); 855166124Srafan compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); 856166124Srafan compute_offset(_eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature()); 857166124Srafan compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature()); 858166124Srafan // The stackSize field is only present starting in 1.4, so don't go fatal. 859166124Srafan compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature()); 860166124Srafan // The tid and thread_status fields are only present starting in 1.5, so don't go fatal. 861166124Srafan compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature()); 862166124Srafan compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature()); 863166124Srafan // The parkBlocker field is only present starting in 1.6, so don't go fatal. 864166124Srafan compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature()); 865166124Srafan compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(), 866166124Srafan vmSymbols::long_signature()); 867166124Srafan} 868166124Srafan 869166124Srafan 870166124SrafanJavaThread* java_lang_Thread::thread(oop java_thread) { 871166124Srafan return (JavaThread*)java_thread->address_field(_eetop_offset); 872166124Srafan} 873166124Srafan 874166124Srafan 875166124Srafanvoid java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) { 876166124Srafan java_thread->address_field_put(_eetop_offset, (address)thread); 877166124Srafan} 878166124Srafan 879166124Srafan 880166124SrafantypeArrayOop java_lang_Thread::name(oop java_thread) { 881166124Srafan oop name = java_thread->obj_field(_name_offset); 882166124Srafan assert(name == NULL || (name->is_typeArray() && TypeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking"); 883166124Srafan return typeArrayOop(name); 884166124Srafan} 885166124Srafan 886166124Srafan 887166124Srafanvoid java_lang_Thread::set_name(oop java_thread, typeArrayOop name) { 888166124Srafan assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL"); 889166124Srafan java_thread->obj_field_put(_name_offset, name); 890174993Srafan} 891174993Srafan 892174993Srafan 893174993SrafanThreadPriority java_lang_Thread::priority(oop java_thread) { 894174993Srafan return (ThreadPriority)java_thread->int_field(_priority_offset); 895174993Srafan} 896174993Srafan 897174993Srafan 898174993Srafanvoid java_lang_Thread::set_priority(oop java_thread, ThreadPriority priority) { 899174993Srafan java_thread->int_field_put(_priority_offset, priority); 900174993Srafan} 901174993Srafan 902174993Srafan 903174993Srafanoop java_lang_Thread::threadGroup(oop java_thread) { 904174993Srafan return java_thread->obj_field(_group_offset); 905174993Srafan} 906174993Srafan 907174993Srafan 908174993Srafanbool java_lang_Thread::is_stillborn(oop java_thread) { 909174993Srafan return java_thread->bool_field(_stillborn_offset) != 0; 910174993Srafan} 911174993Srafan 912174993Srafan 913174993Srafan// We never have reason to turn the stillborn bit off 914174993Srafanvoid java_lang_Thread::set_stillborn(oop java_thread) { 915174993Srafan java_thread->bool_field_put(_stillborn_offset, true); 916174993Srafan} 917174993Srafan 91876726Speter 919174993Srafanbool java_lang_Thread::is_alive(oop java_thread) { 92076726Speter JavaThread* thr = java_lang_Thread::thread(java_thread); 92176726Speter return (thr != NULL); 922166124Srafan} 923166124Srafan 92476726Speter 925166124Srafanbool java_lang_Thread::is_daemon(oop java_thread) { 92676726Speter return java_thread->bool_field(_daemon_offset) != 0; 927166124Srafan} 928166124Srafan 92950276Speter 93050276Spetervoid java_lang_Thread::set_daemon(oop java_thread) { 93150276Speter java_thread->bool_field_put(_daemon_offset, true); 93250276Speter} 93350276Speter 93450276Speteroop java_lang_Thread::context_class_loader(oop java_thread) { 93597049Speter return java_thread->obj_field(_contextClassLoader_offset); 93697049Speter} 93797049Speter 93897049Speteroop java_lang_Thread::inherited_access_control_context(oop java_thread) { 93997049Speter return java_thread->obj_field(_inheritedAccessControlContext_offset); 94050276Speter} 94150276Speter 94250276Speter 94350276Speterjlong java_lang_Thread::stackSize(oop java_thread) { 94450276Speter // The stackSize field is only present starting in 1.4 94550276Speter if (_stackSize_offset > 0) { 94650276Speter assert(JDK_Version::is_gte_jdk14x_version(), "sanity check"); 94750276Speter return java_thread->long_field(_stackSize_offset); 948166124Srafan } else { 949166124Srafan return 0; 950166124Srafan } 951166124Srafan} 952166124Srafan 953166124Srafan// Write the thread status value to threadStatus field in java.lang.Thread java class. 954166124Srafanvoid java_lang_Thread::set_thread_status(oop java_thread, 955166124Srafan java_lang_Thread::ThreadStatus status) { 956166124Srafan // The threadStatus is only present starting in 1.5 957166124Srafan if (_thread_status_offset > 0) { 958166124Srafan java_thread->int_field_put(_thread_status_offset, status); 959166124Srafan } 960166124Srafan} 961166124Srafan 962166124Srafan// Read thread status value from threadStatus field in java.lang.Thread java class. 963166124Srafanjava_lang_Thread::ThreadStatus java_lang_Thread::get_thread_status(oop java_thread) { 964166124Srafan assert(Thread::current()->is_Watcher_thread() || Thread::current()->is_VM_thread() || 965166124Srafan JavaThread::current()->thread_state() == _thread_in_vm, 966166124Srafan "Java Thread is not running in vm"); 967166124Srafan // The threadStatus is only present starting in 1.5 968166124Srafan if (_thread_status_offset > 0) { 969166124Srafan return (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset); 970184989Srafan } else { 971184989Srafan // All we can easily figure out is if it is alive, but that is 972184989Srafan // enough info for a valid unknown status. 973184989Srafan // These aren't restricted to valid set ThreadStatus values, so 974184989Srafan // use JVMTI values and cast. 975184989Srafan JavaThread* thr = java_lang_Thread::thread(java_thread); 976184989Srafan if (thr == NULL) { 977184989Srafan // the thread hasn't run yet or is in the process of exiting 978184989Srafan return NEW; 979184989Srafan } 980184989Srafan return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE; 981184989Srafan } 982184989Srafan} 983184989Srafan 984166124Srafan 985166124Srafanjlong java_lang_Thread::thread_id(oop java_thread) { 98650276Speter // The thread ID field is only present starting in 1.5 98750276Speter if (_tid_offset > 0) { 98850276Speter return java_thread->long_field(_tid_offset); 98950276Speter } else { 99050276Speter return 0; 99150276Speter } 992166124Srafan} 993166124Srafan 99450276Speteroop java_lang_Thread::park_blocker(oop java_thread) { 99550276Speter assert(JDK_Version::current().supports_thread_park_blocker() && 99650276Speter _park_blocker_offset != 0, "Must support parkBlocker field"); 99750276Speter 99850276Speter if (_park_blocker_offset > 0) { 99950276Speter return java_thread->obj_field(_park_blocker_offset); 100050276Speter } 100150276Speter 100250276Speter return NULL; 100350276Speter} 100450276Speter 1005166124Srafanjlong java_lang_Thread::park_event(oop java_thread) { 100650276Speter if (_park_event_offset > 0) { 100750276Speter return java_thread->long_field(_park_event_offset); 100850276Speter } 100950276Speter return 0; 101050276Speter} 101156639Speter 101256639Speterbool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) { 101350276Speter if (_park_event_offset > 0) { 101450276Speter java_thread->long_field_put(_park_event_offset, ptr); 101550276Speter return true; 101650276Speter } 101750276Speter return false; 101850276Speter} 101950276Speter 102050276Speter 102150276Speterconst char* java_lang_Thread::thread_status_name(oop java_thread) { 1022184989Srafan assert(JDK_Version::is_gte_jdk15x_version() && _thread_status_offset != 0, "Must have thread status"); 1023184989Srafan ThreadStatus status = (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset); 1024184989Srafan switch (status) { 1025184989Srafan case NEW : return "NEW"; 1026184989Srafan case RUNNABLE : return "RUNNABLE"; 1027184989Srafan case SLEEPING : return "TIMED_WAITING (sleeping)"; 1028184989Srafan case IN_OBJECT_WAIT : return "WAITING (on object monitor)"; 1029184989Srafan case IN_OBJECT_WAIT_TIMED : return "TIMED_WAITING (on object monitor)"; 1030184989Srafan case PARKED : return "WAITING (parking)"; 1031184989Srafan case PARKED_TIMED : return "TIMED_WAITING (parking)"; 1032184989Srafan case BLOCKED_ON_MONITOR_ENTER : return "BLOCKED (on object monitor)"; 1033184989Srafan case TERMINATED : return "TERMINATED"; 1034184989Srafan default : return "UNKNOWN"; 1035184989Srafan }; 1036184989Srafan} 1037184989Srafanint java_lang_ThreadGroup::_parent_offset = 0; 1038184989Srafanint java_lang_ThreadGroup::_name_offset = 0; 1039184989Srafanint java_lang_ThreadGroup::_threads_offset = 0; 1040184989Srafanint java_lang_ThreadGroup::_groups_offset = 0; 1041184989Srafanint java_lang_ThreadGroup::_maxPriority_offset = 0; 1042184989Srafanint java_lang_ThreadGroup::_destroyed_offset = 0; 1043184989Srafanint java_lang_ThreadGroup::_daemon_offset = 0; 1044184989Srafanint java_lang_ThreadGroup::_vmAllowSuspension_offset = 0; 1045184989Srafanint java_lang_ThreadGroup::_nthreads_offset = 0; 1046184989Srafanint java_lang_ThreadGroup::_ngroups_offset = 0; 1047184989Srafan 1048184989Srafanoop java_lang_ThreadGroup::parent(oop java_thread_group) { 1049184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1050184989Srafan return java_thread_group->obj_field(_parent_offset); 1051184989Srafan} 1052184989Srafan 1053184989Srafan// ("name as oop" accessor is not necessary) 1054184989Srafan 1055184989SrafantypeArrayOop java_lang_ThreadGroup::name(oop java_thread_group) { 1056184989Srafan oop name = java_thread_group->obj_field(_name_offset); 1057184989Srafan // ThreadGroup.name can be null 1058184989Srafan return name == NULL ? (typeArrayOop)NULL : java_lang_String::value(name); 1059184989Srafan} 1060184989Srafan 1061184989Srafanint java_lang_ThreadGroup::nthreads(oop java_thread_group) { 1062184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1063184989Srafan return java_thread_group->int_field(_nthreads_offset); 1064184989Srafan} 1065184989Srafan 1066184989SrafanobjArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) { 1067184989Srafan oop threads = java_thread_group->obj_field(_threads_offset); 1068184989Srafan assert(threads != NULL, "threadgroups should have threads"); 1069184989Srafan assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code 1070184989Srafan return objArrayOop(threads); 1071184989Srafan} 1072184989Srafan 1073184989Srafanint java_lang_ThreadGroup::ngroups(oop java_thread_group) { 1074184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1075184989Srafan return java_thread_group->int_field(_ngroups_offset); 1076184989Srafan} 1077184989Srafan 1078184989SrafanobjArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) { 1079184989Srafan oop groups = java_thread_group->obj_field(_groups_offset); 1080184989Srafan assert(groups == NULL || groups->is_objArray(), "just checking"); // Todo: Add better type checking code 1081184989Srafan return objArrayOop(groups); 1082184989Srafan} 1083184989Srafan 1084184989SrafanThreadPriority java_lang_ThreadGroup::maxPriority(oop java_thread_group) { 1085184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1086184989Srafan return (ThreadPriority) java_thread_group->int_field(_maxPriority_offset); 1087184989Srafan} 1088184989Srafan 1089184989Srafanbool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) { 1090184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1091184989Srafan return java_thread_group->bool_field(_destroyed_offset) != 0; 1092184989Srafan} 1093184989Srafan 1094184989Srafanbool java_lang_ThreadGroup::is_daemon(oop java_thread_group) { 1095184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1096184989Srafan return java_thread_group->bool_field(_daemon_offset) != 0; 1097184989Srafan} 1098184989Srafan 1099184989Srafanbool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) { 1100184989Srafan assert(java_thread_group->is_oop(), "thread group must be oop"); 1101184989Srafan return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0; 1102184989Srafan} 1103184989Srafan 1104184989Srafanvoid java_lang_ThreadGroup::compute_offsets() { 1105184989Srafan assert(_parent_offset == 0, "offsets should be initialized only once"); 1106184989Srafan 1107184989Srafan Klass* k = SystemDictionary::ThreadGroup_klass(); 1108184989Srafan 1109184989Srafan compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); 1110184989Srafan compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 1111184989Srafan compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); 1112184989Srafan compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); 1113184989Srafan compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature()); 1114184989Srafan compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature()); 1115184989Srafan compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); 1116184989Srafan compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature()); 1117184989Srafan compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); 1118184989Srafan compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); 1119184989Srafan} 1120184989Srafan 1121184989Srafanoop java_lang_Throwable::unassigned_stacktrace() { 1122184989Srafan InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Throwable_klass()); 1123184989Srafan address addr = ik->static_field_addr(static_unassigned_stacktrace_offset); 1124184989Srafan if (UseCompressedOops) { 1125184989Srafan return oopDesc::load_decode_heap_oop((narrowOop *)addr); 1126184989Srafan } else { 1127184989Srafan return oopDesc::load_decode_heap_oop((oop*)addr); 1128184989Srafan } 1129184989Srafan} 1130184989Srafan 1131184989Srafanoop java_lang_Throwable::backtrace(oop throwable) { 1132184989Srafan return throwable->obj_field_acquire(backtrace_offset); 1133184989Srafan} 1134166124Srafan 1135166124Srafan 1136166124Srafanvoid java_lang_Throwable::set_backtrace(oop throwable, oop value) { 1137166124Srafan throwable->release_obj_field_put(backtrace_offset, value); 1138166124Srafan} 1139166124Srafan 1140166124Srafan 1141166124Srafanoop java_lang_Throwable::message(oop throwable) { 1142166124Srafan return throwable->obj_field(detailMessage_offset); 1143166124Srafan} 1144166124Srafan 1145166124Srafan 1146166124Srafanoop java_lang_Throwable::message(Handle throwable) { 1147166124Srafan return throwable->obj_field(detailMessage_offset); 1148166124Srafan} 1149166124Srafan 1150166124Srafan 1151166124Srafanvoid java_lang_Throwable::set_message(oop throwable, oop value) { 1152166124Srafan throwable->obj_field_put(detailMessage_offset, value); 1153166124Srafan} 1154166124Srafan 1155166124Srafan 1156166124Srafanvoid java_lang_Throwable::set_stacktrace(oop throwable, oop st_element_array) { 1157166124Srafan throwable->obj_field_put(stackTrace_offset, st_element_array); 1158166124Srafan} 1159166124Srafan 1160166124Srafanvoid java_lang_Throwable::clear_stacktrace(oop throwable) { 1161166124Srafan assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); 1162166124Srafan set_stacktrace(throwable, NULL); 1163166124Srafan} 1164166124Srafan 1165166124Srafan 1166166124Srafanvoid java_lang_Throwable::print(oop throwable, outputStream* st) { 1167166124Srafan ResourceMark rm; 1168166124Srafan Klass* k = throwable->klass(); 1169166124Srafan assert(k != NULL, "just checking"); 1170166124Srafan st->print("%s", InstanceKlass::cast(k)->external_name()); 117150276Speter oop msg = message(throwable); 117250276Speter if (msg != NULL) { 117350276Speter st->print(": %s", java_lang_String::as_utf8_string(msg)); 117450276Speter } 117550276Speter} 117650276Speter 117750276Speter 117850276Spetervoid java_lang_Throwable::print(Handle throwable, outputStream* st) { 117950276Speter ResourceMark rm; 118050276Speter Klass* k = throwable->klass(); 118150276Speter assert(k != NULL, "just checking"); 118250276Speter st->print("%s", InstanceKlass::cast(k)->external_name()); 118350276Speter oop msg = message(throwable); 118450276Speter if (msg != NULL) { 1185166124Srafan st->print(": %s", java_lang_String::as_utf8_string(msg)); 118650276Speter } 118750276Speter} 118850276Speter 118950276Speter// After this many redefines, the stack trace is unreliable. 119050276Speterconst int MAX_VERSION = USHRT_MAX; 119150276Speter 119250276Speter// Helper backtrace functions to store bci|version together. 119366963Speterstatic inline int merge_bci_and_version(int bci, int version) { 119450276Speter // only store u2 for version, checking for overflow. 119550276Speter if (version > USHRT_MAX || version < 0) version = MAX_VERSION; 119650276Speter assert((jushort)bci == bci, "bci should be short"); 119750276Speter return build_int_from_shorts(version, bci); 119850276Speter} 119950276Speter 1200166124Srafanstatic inline int bci_at(unsigned int merged) { 1201166124Srafan return extract_high_short_from_int(merged); 1202166124Srafan} 1203166124Srafanstatic inline int version_at(unsigned int merged) { 1204166124Srafan return extract_low_short_from_int(merged); 1205166124Srafan} 1206166124Srafan 1207166124Srafanstatic inline bool version_matches(Method* method, int version) { 1208166124Srafan return (method->constants()->version() == version && version < MAX_VERSION); 1209166124Srafan} 1210166124Srafan 1211166124Srafanstatic inline int get_line_number(Method* method, int bci) { 1212166124Srafan int line_number = 0; 1213166124Srafan if (method->is_native()) { 1214166124Srafan // Negative value different from -1 below, enabling Java code in 1215166124Srafan // class java.lang.StackTraceElement to distinguish "native" from 1216166124Srafan // "no LineNumberTable". JDK tests for -2. 1217166124Srafan line_number = -2; 1218166124Srafan } else { 1219166124Srafan // Returns -1 if no LineNumberTable, and otherwise actual line number 1220166124Srafan line_number = method->line_number_from_bci(bci); 1221166124Srafan if (line_number == -1 && ShowHiddenFrames) { 1222166124Srafan line_number = bci + 1000000; 1223166124Srafan } 1224166124Srafan } 1225166124Srafan return line_number; 1226166124Srafan} 1227166124Srafan 1228166124Srafan// This class provides a simple wrapper over the internal structure of 1229166124Srafan// exception backtrace to insulate users of the backtrace from needing 1230166124Srafan// to know what it looks like. 1231166124Srafanclass BacktraceBuilder: public StackObj { 1232166124Srafan private: 1233166124Srafan Handle _backtrace; 1234178866Srafan objArrayOop _head; 1235178866Srafan typeArrayOop _methods; 1236178866Srafan typeArrayOop _bcis; 1237178866Srafan objArrayOop _mirrors; 1238178866Srafan int _index; 1239178866Srafan No_Safepoint_Verifier _nsv; 1240178866Srafan 1241178866Srafan public: 1242178866Srafan 1243178866Srafan enum { 1244178866Srafan trace_methods_offset = java_lang_Throwable::trace_methods_offset, 1245178866Srafan trace_bcis_offset = java_lang_Throwable::trace_bcis_offset, 1246178866Srafan trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset, 1247178866Srafan trace_next_offset = java_lang_Throwable::trace_next_offset, 1248178866Srafan trace_size = java_lang_Throwable::trace_size, 1249178866Srafan trace_chunk_size = java_lang_Throwable::trace_chunk_size 1250178866Srafan }; 1251178866Srafan 1252178866Srafan // get info out of chunks 1253178866Srafan static typeArrayOop get_methods(objArrayHandle chunk) { 1254178866Srafan typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset)); 1255178866Srafan assert(methods != NULL, "method array should be initialized in backtrace"); 1256178866Srafan return methods; 1257178866Srafan } 1258178866Srafan static typeArrayOop get_bcis(objArrayHandle chunk) { 1259178866Srafan typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); 1260178866Srafan assert(bcis != NULL, "bci array should be initialized in backtrace"); 1261178866Srafan return bcis; 1262166124Srafan } 1263166124Srafan static objArrayOop get_mirrors(objArrayHandle chunk) { 126462449Speter objArrayOop mirrors = objArrayOop(chunk->obj_at(trace_mirrors_offset)); 126562449Speter assert(mirrors != NULL, "mirror array should be initialized in backtrace"); 126662449Speter return mirrors; 126762449Speter } 126862449Speter 126962449Speter // constructor for new backtrace 127062449Speter BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL) { 127162449Speter expand(CHECK); 127262449Speter _backtrace = _head; 127362449Speter _index = 0; 127462449Speter } 127562449Speter 127662449Speter BacktraceBuilder(objArrayHandle backtrace) { 127762449Speter _methods = get_methods(backtrace); 127862449Speter _bcis = get_bcis(backtrace); 127962449Speter _mirrors = get_mirrors(backtrace); 128062449Speter assert(_methods->length() == _bcis->length() && 128162449Speter _methods->length() == _mirrors->length(), 128262449Speter "method and source information arrays should match"); 1283166124Srafan 128462449Speter // head is the preallocated backtrace 128562449Speter _backtrace = _head = backtrace(); 128662449Speter _index = 0; 128762449Speter } 128862449Speter 128962449Speter void expand(TRAPS) { 129062449Speter objArrayHandle old_head(THREAD, _head); 1291166124Srafan Pause_No_Safepoint_Verifier pnsv(&_nsv); 1292166124Srafan 129366963Speter objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); 129466963Speter objArrayHandle new_head(THREAD, head); 129566963Speter 129666963Speter typeArrayOop methods = oopFactory::new_shortArray(trace_chunk_size, CHECK); 129766963Speter typeArrayHandle new_methods(THREAD, methods); 129866963Speter 129966963Speter typeArrayOop bcis = oopFactory::new_intArray(trace_chunk_size, CHECK); 130066963Speter typeArrayHandle new_bcis(THREAD, bcis); 130166963Speter 130266963Speter objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK); 130366963Speter objArrayHandle new_mirrors(THREAD, mirrors); 130466963Speter 130566963Speter if (!old_head.is_null()) { 130666963Speter old_head->obj_at_put(trace_next_offset, new_head()); 130766963Speter } 130866963Speter new_head->obj_at_put(trace_methods_offset, new_methods()); 130966963Speter new_head->obj_at_put(trace_bcis_offset, new_bcis()); 131066963Speter new_head->obj_at_put(trace_mirrors_offset, new_mirrors()); 131166963Speter 131266963Speter _head = new_head(); 131366963Speter _methods = new_methods(); 131466963Speter _bcis = new_bcis(); 131566963Speter _mirrors = new_mirrors(); 131666963Speter _index = 0; 131766963Speter } 131866963Speter 131966963Speter oop backtrace() { 1320166124Srafan return _backtrace(); 1321166124Srafan } 132297049Speter 132397049Speter inline void push(Method* method, int bci, TRAPS) { 132497049Speter // Smear the -1 bci to 0 since the array only holds unsigned 132597049Speter // shorts. The later line number lookup would just smear the -1 132697049Speter // to a 0 even if it could be recorded. 132797049Speter if (bci == SynchronizationEntryBCI) bci = 0; 132897049Speter 132997049Speter if (_index >= trace_chunk_size) { 133097049Speter methodHandle mhandle(THREAD, method); 133197049Speter expand(CHECK); 133297049Speter method = mhandle(); 133397049Speter } 133497049Speter 133597049Speter _methods->short_at_put(_index, method->method_idnum()); 133697049Speter _bcis->int_at_put(_index, merge_bci_and_version(bci, method->constants()->version())); 133797049Speter 133897049Speter // We need to save the mirrors in the backtrace to keep the class 133997049Speter // from being unloaded while we still have this stack trace. 134097049Speter assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror"); 134197049Speter _mirrors->obj_at_put(_index, method->method_holder()->java_mirror()); 134297049Speter _index++; 134397049Speter } 134497049Speter 134597049Speter}; 134697049Speter 134797049Speter// Print stack trace element to resource allocated buffer 134897049Speterchar* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror, 134997049Speter int method_id, int version, int bci) { 135097049Speter 135197049Speter // Get strings and string lengths 135297049Speter InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror())); 135397049Speter const char* klass_name = holder->external_name(); 135497049Speter int buf_len = (int)strlen(klass_name); 135597049Speter 135697049Speter // pushing to the stack trace added one. 135797049Speter Method* method = holder->method_with_idnum(method_id); 135897049Speter char* method_name = method->name()->as_C_string(); 135997049Speter buf_len += (int)strlen(method_name); 136097049Speter 136197049Speter char* source_file_name = NULL; 136297049Speter if (version_matches(method, version)) { 136397049Speter Symbol* source = holder->source_file_name(); 136497049Speter if (source != NULL) { 1365174993Srafan source_file_name = source->as_C_string(); 1366166124Srafan buf_len += (int)strlen(source_file_name); 136750276Speter } 136850276Speter } 136950276Speter 137050276Speter // Allocate temporary buffer with extra space for formatting and line number 137150276Speter char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64); 137266963Speter 137350276Speter // Print stack trace line in buffer 137450276Speter sprintf(buf, "\tat %s.%s", klass_name, method_name); 137550276Speter 137650276Speter if (!version_matches(method, version)) { 137750276Speter strcat(buf, "(Redefined)"); 137850276Speter } else { 137950276Speter int line_number = get_line_number(method, bci); 138050276Speter if (line_number == -2) { 138150276Speter strcat(buf, "(Native Method)"); 138250276Speter } else { 138350276Speter if (source_file_name != NULL && (line_number != -1)) { 138450276Speter // Sourcename and linenumber 138550276Speter sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number); 138650276Speter } else if (source_file_name != NULL) { 138750276Speter // Just sourcename 138866963Speter sprintf(buf + (int)strlen(buf), "(%s)", source_file_name); 138950276Speter } else { 139056639Speter // Neither sourcename nor linenumber 139150276Speter sprintf(buf + (int)strlen(buf), "(Unknown Source)"); 1392174993Srafan } 139350276Speter nmethod* nm = method->code(); 139450276Speter if (WizardMode && nm != NULL) { 139550276Speter sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm); 139650276Speter } 139750276Speter } 139850276Speter } 139950276Speter 140050276Speter return buf; 140150276Speter} 140250276Speter 140350276Spetervoid java_lang_Throwable::print_stack_element(outputStream *st, Handle mirror, 140450276Speter int method_id, int version, int bci) { 140550276Speter ResourceMark rm; 140650276Speter char* buf = print_stack_element_to_buffer(mirror, method_id, version, bci); 140750276Speter st->print_cr("%s", buf); 140850276Speter} 140976726Speter 141050276Spetervoid java_lang_Throwable::print_stack_element(outputStream *st, methodHandle method, int bci) { 141150276Speter Handle mirror = method->method_holder()->java_mirror(); 141250276Speter int method_id = method->method_idnum(); 1413166124Srafan int version = method->constants()->version(); 141450276Speter print_stack_element(st, mirror, method_id, version, bci); 141556639Speter} 141650276Speter 141750276Speterconst char* java_lang_Throwable::no_stack_trace_message() { 141850276Speter return "\t<<no stack trace available>>"; 1419166124Srafan} 142050276Speter 142150276Speter 142250276Speter// Currently used only for exceptions occurring during startup 142350276Spetervoid java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) { 1424166124Srafan Thread *THREAD = Thread::current(); 142550276Speter Handle h_throwable(THREAD, throwable); 142650276Speter while (h_throwable.not_null()) { 142750276Speter objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable()))); 142850276Speter if (result.is_null()) { 142950276Speter st->print_cr(no_stack_trace_message()); 143050276Speter return; 143150276Speter } 143250276Speter 143350276Speter while (result.not_null()) { 143450276Speter 143550276Speter // Get method id, bci, version and mirror from chunk 143650276Speter typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result)); 143750276Speter typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result)); 143850276Speter objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result)); 143950276Speter 1440166124Srafan int length = methods()->length(); 1441166124Srafan for (int index = 0; index < length; index++) { 1442166124Srafan Handle mirror(THREAD, mirrors->obj_at(index)); 1443166124Srafan // NULL mirror means end of stack trace 1444166124Srafan if (mirror.is_null()) goto handle_cause; 1445166124Srafan int method = methods->short_at(index); 1446166124Srafan int version = version_at(bcis->int_at(index)); 1447166124Srafan int bci = bci_at(bcis->int_at(index)); 1448166124Srafan print_stack_element(st, mirror, method, version, bci); 1449166124Srafan } 1450166124Srafan result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset))); 1451166124Srafan } 1452166124Srafan handle_cause: 1453166124Srafan { 1454184989Srafan EXCEPTION_MARK; 1455166124Srafan JavaValue cause(T_OBJECT); 145650276Speter JavaCalls::call_virtual(&cause, 145750276Speter h_throwable, 145850276Speter KlassHandle(THREAD, h_throwable->klass()), 145950276Speter vmSymbols::getCause_name(), 146050276Speter vmSymbols::void_throwable_signature(), 146150276Speter THREAD); 1462166124Srafan // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. 1463166124Srafan if (HAS_PENDING_EXCEPTION) { 146450276Speter CLEAR_PENDING_EXCEPTION; 146550276Speter h_throwable = Handle(); 1466166124Srafan } else { 1467166124Srafan h_throwable = Handle(THREAD, (oop) cause.get_jobject()); 1468166124Srafan if (h_throwable.not_null()) { 1469166124Srafan st->print("Caused by: "); 1470166124Srafan print(h_throwable, st); 1471166124Srafan st->cr(); 1472166124Srafan } 147350276Speter } 147450276Speter } 1475166124Srafan } 1476166124Srafan} 1477166124Srafan 1478166124Srafanvoid java_lang_Throwable::fill_in_stack_trace(Handle throwable, methodHandle method, TRAPS) { 1479174993Srafan if (!StackTraceInThrowable) return; 148076726Speter ResourceMark rm(THREAD); 148150276Speter 1482166124Srafan // Start out by clearing the backtrace for this object, in case the VM 1483166124Srafan // runs out of memory while allocating the stack trace 1484166124Srafan set_backtrace(throwable(), NULL); 1485166124Srafan if (JDK_Version::is_gte_jdk14x_version()) { 1486166124Srafan // New since 1.4, clear lazily constructed Java level stacktrace if 1487166124Srafan // refilling occurs 1488166124Srafan // This is unnecessary in 1.7+ but harmless 1489166124Srafan clear_stacktrace(throwable()); 1490166124Srafan } 1491166124Srafan 1492166124Srafan int max_depth = MaxJavaStackTraceDepth; 1493166124Srafan JavaThread* thread = (JavaThread*)THREAD; 1494166124Srafan BacktraceBuilder bt(CHECK); 1495166124Srafan 1496166124Srafan // If there is no Java frame just return the method that was being called 149756639Speter // with bci 0 149850276Speter if (!thread->has_last_Java_frame()) { 1499166124Srafan if (max_depth >= 1 && method() != NULL) { 1500174993Srafan bt.push(method(), 0, CHECK); 1501166124Srafan set_backtrace(throwable(), bt.backtrace()); 1502166124Srafan } 1503166124Srafan return; 1504166124Srafan } 1505166124Srafan 1506166124Srafan // Instead of using vframe directly, this version of fill_in_stack_trace 1507166124Srafan // basically handles everything by hand. This significantly improved the 1508166124Srafan // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows. 1509166124Srafan // See bug 6333838 for more details. 1510166124Srafan // The "ASSERT" here is to verify this method generates the exactly same stack 1511166124Srafan // trace as utilizing vframe. 1512166124Srafan#ifdef ASSERT 1513166124Srafan vframeStream st(thread); 1514166124Srafan methodHandle st_method(THREAD, st.method()); 1515166124Srafan#endif 1516166124Srafan int total_count = 0; 1517166124Srafan RegisterMap map(thread, false); 1518166124Srafan int decode_offset = 0; 1519166124Srafan nmethod* nm = NULL; 1520166124Srafan bool skip_fillInStackTrace_check = false; 1521166124Srafan bool skip_throwableInit_check = false; 1522166124Srafan bool skip_hidden = !ShowHiddenFrames; 1523166124Srafan 152450276Speter for (frame fr = thread->last_frame(); max_depth != total_count;) { 152550276Speter Method* method = NULL; 152650276Speter int bci = 0; 152750276Speter 152850276Speter // Compiled java method case. 152950276Speter if (decode_offset != 0) { 153050276Speter DebugInfoReadStream stream(nm, decode_offset); 153150276Speter decode_offset = stream.read_int(); 153250276Speter method = (Method*)nm->metadata_at(stream.read_int()); 153350276Speter bci = stream.read_bci(); 153450276Speter } else { 153550276Speter if (fr.is_first_frame()) break; 153650276Speter address pc = fr.pc(); 1537166124Srafan if (fr.is_interpreted_frame()) { 1538166124Srafan intptr_t bcx = fr.interpreter_frame_bcx(); 153950276Speter method = fr.interpreter_frame_method(); 154050276Speter bci = fr.is_bci(bcx) ? bcx : method->bci_from((address)bcx); 154150276Speter fr = fr.sender(&map); 154250276Speter } else { 1543166124Srafan CodeBlob* cb = fr.cb(); 1544166124Srafan // HMMM QQQ might be nice to have frame return nm as NULL if cb is non-NULL 1545166124Srafan // but non nmethod 1546166124Srafan fr = fr.sender(&map); 1547166124Srafan if (cb == NULL || !cb->is_nmethod()) { 1548166124Srafan continue; 1549184989Srafan } 1550166124Srafan nm = (nmethod*)cb; 1551166124Srafan if (nm->method()->is_native()) { 1552166124Srafan method = nm->method(); 1553166124Srafan bci = 0; 1554166124Srafan } else { 155550276Speter PcDesc* pd = nm->pc_desc_at(pc); 155650276Speter decode_offset = pd->scope_decode_offset(); 155750276Speter // if decode_offset is not equal to 0, it will execute the 155850276Speter // "compiled java method case" at the beginning of the loop. 155950276Speter continue; 1560166124Srafan } 1561166124Srafan } 156250276Speter } 156350276Speter#ifdef ASSERT 156450276Speter assert(st_method() == method && st.bci() == bci, 1565166124Srafan "Wrong stack trace"); 1566166124Srafan st.next(); 1567166124Srafan // vframeStream::method isn't GC-safe so store off a copy 1568166124Srafan // of the Method* in case we GC. 1569166124Srafan if (!st.at_end()) { 1570166124Srafan st_method = st.method(); 1571166124Srafan } 1572166124Srafan#endif 1573166124Srafan 1574166124Srafan // the format of the stacktrace will be: 1575166124Srafan // - 1 or more fillInStackTrace frames for the exception class (skipped) 1576166124Srafan // - 0 or more <init> methods for the exception class (skipped) 1577166124Srafan // - rest of the stack 1578166124Srafan 1579166124Srafan if (!skip_fillInStackTrace_check) { 1580166124Srafan if ((method->name() == vmSymbols::fillInStackTrace_name() || 1581166124Srafan method->name() == vmSymbols::fillInStackTrace0_name()) && 1582166124Srafan throwable->is_a(method->method_holder())) { 1583166124Srafan continue; 1584166124Srafan } 1585166124Srafan else { 1586166124Srafan skip_fillInStackTrace_check = true; // gone past them all 1587166124Srafan } 1588166124Srafan } 1589166124Srafan if (!skip_throwableInit_check) { 1590166124Srafan assert(skip_fillInStackTrace_check, "logic error in backtrace filtering"); 1591166124Srafan 1592166124Srafan // skip <init> methods of the exception class and superclasses 1593166124Srafan // This is simlar to classic VM. 159450276Speter if (method->name() == vmSymbols::object_initializer_name() && 159550276Speter throwable->is_a(method->method_holder())) { 1596166124Srafan continue; 1597166124Srafan } else { 1598166124Srafan // there are none or we've seen them all - either way stop checking 1599166124Srafan skip_throwableInit_check = true; 1600166124Srafan } 1601166124Srafan } 160250276Speter if (method->is_hidden()) { 160350276Speter if (skip_hidden) continue; 160450276Speter } 160550276Speter bt.push(method, bci, CHECK); 160650276Speter total_count++; 160750276Speter } 160850276Speter 160950276Speter // Put completed stack trace into throwable object 161050276Speter set_backtrace(throwable(), bt.backtrace()); 1611166124Srafan} 161250276Speter 161350276Spetervoid java_lang_Throwable::fill_in_stack_trace(Handle throwable, methodHandle method) { 161450276Speter // No-op if stack trace is disabled 161550276Speter if (!StackTraceInThrowable) { 161650276Speter return; 161750276Speter } 161850276Speter 161950276Speter // Disable stack traces for some preallocated out of memory errors 162050276Speter if (!Universe::should_fill_in_stack_trace(throwable)) { 162150276Speter return; 162250276Speter } 1623166124Srafan 1624166124Srafan PRESERVE_EXCEPTION_MARK; 1625166124Srafan 162650276Speter JavaThread* thread = JavaThread::active(); 162750276Speter fill_in_stack_trace(throwable, method, thread); 1628166124Srafan // ignore exceptions thrown during stack trace filling 1629166124Srafan CLEAR_PENDING_EXCEPTION; 1630166124Srafan} 1631166124Srafan 1632166124Srafanvoid java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) { 1633166124Srafan // Allocate stack trace - backtrace is created but not filled in 163476726Speter 163550276Speter // No-op if stack trace is disabled 163650276Speter if (!StackTraceInThrowable) return; 1637166124Srafan BacktraceBuilder bt(CHECK); // creates a backtrace 163850276Speter set_backtrace(throwable(), bt.backtrace()); 163950276Speter} 164050276Speter 1641166124Srafan 1642166124Srafanvoid java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) { 164350276Speter // Fill in stack trace into preallocated backtrace (no GC) 1644166124Srafan 164550276Speter // No-op if stack trace is disabled 164650276Speter if (!StackTraceInThrowable) return; 164750276Speter 164850276Speter assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check"); 164950276Speter 165050276Speter JavaThread* THREAD = JavaThread::current(); 165150276Speter 1652166124Srafan objArrayHandle backtrace (THREAD, (objArrayOop)java_lang_Throwable::backtrace(throwable())); 1653166124Srafan assert(backtrace.not_null(), "backtrace should have been preallocated"); 165497049Speter 165597049Speter ResourceMark rm(THREAD); 165697049Speter vframeStream st(THREAD); 165797049Speter 165897049Speter BacktraceBuilder bt(backtrace); 165997049Speter 166097049Speter // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init 166197049Speter // methods as preallocated errors aren't created by "java" code. 166297049Speter 166397049Speter // fill in as much stack trace as possible 166497049Speter typeArrayOop methods = BacktraceBuilder::get_methods(backtrace); 166597049Speter int max_chunks = MIN2(methods->length(), (int)MaxJavaStackTraceDepth); 166697049Speter int chunk_count = 0; 166797049Speter 166897049Speter for (;!st.at_end(); st.next()) { 166997049Speter bt.push(st.method(), st.bci(), CHECK); 167097049Speter chunk_count++; 167197049Speter 167297049Speter // Bail-out for deep stacks 167397049Speter if (chunk_count >= max_chunks) break; 167497049Speter } 167597049Speter 167697049Speter // For Java 7+ we support the Throwable immutability protocol defined for Java 7. This support 167797049Speter // was missing in 7u0 so in 7u0 there is a workaround in the Throwable class. That workaround 167897049Speter // can be removed in a JDK using this JVM version 167997049Speter if (JDK_Version::is_gte_jdk17x_version()) { 168097049Speter java_lang_Throwable::set_stacktrace(throwable(), java_lang_Throwable::unassigned_stacktrace()); 168197049Speter assert(java_lang_Throwable::unassigned_stacktrace() != NULL, "not initialized"); 1682166124Srafan } 1683166124Srafan} 168456639Speter 168556639Speter 168656639Speterint java_lang_Throwable::get_stack_trace_depth(oop throwable, TRAPS) { 168756639Speter if (throwable == NULL) { 168856639Speter THROW_0(vmSymbols::java_lang_NullPointerException()); 168956639Speter } 169056639Speter objArrayOop chunk = objArrayOop(backtrace(throwable)); 169156639Speter int depth = 0; 169256639Speter if (chunk != NULL) { 169356639Speter // Iterate over chunks and count full ones 169456639Speter while (true) { 169556639Speter objArrayOop next = objArrayOop(chunk->obj_at(trace_next_offset)); 169656639Speter if (next == NULL) break; 169756639Speter depth += trace_chunk_size; 1698166124Srafan chunk = next; 169956639Speter } 170056639Speter assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check"); 170162449Speter // Count element in remaining partial chunk. NULL value for mirror 170256639Speter // marks the end of the stack trace elements that are saved. 170356639Speter objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk); 170456639Speter assert(mirrors != NULL, "sanity check"); 170562449Speter for (int i = 0; i < mirrors->length(); i++) { 170656639Speter if (mirrors->obj_at(i) == NULL) break; 170762449Speter depth++; 170856639Speter } 170956639Speter } 171056639Speter return depth; 171156639Speter} 171256639Speter 171356639Speter 171456639Speteroop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) { 171556639Speter if (throwable == NULL) { 171662449Speter THROW_0(vmSymbols::java_lang_NullPointerException()); 171756639Speter } 171862449Speter if (index < 0) { 171956639Speter THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); 172056639Speter } 172156639Speter // Compute how many chunks to skip and index into actual chunk 172256639Speter objArrayOop chunk = objArrayOop(backtrace(throwable)); 172356639Speter int skip_chunks = index / trace_chunk_size; 172456639Speter int chunk_index = index % trace_chunk_size; 172556639Speter while (chunk != NULL && skip_chunks > 0) { 1726166124Srafan chunk = objArrayOop(chunk->obj_at(trace_next_offset)); 1727166124Srafan skip_chunks--; 1728166124Srafan } 1729166124Srafan if (chunk == NULL) { 1730166124Srafan THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); 1731166124Srafan } 1732166124Srafan // Get method id, bci, version and mirror from chunk 1733166124Srafan typeArrayOop methods = BacktraceBuilder::get_methods(chunk); 1734166124Srafan typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk); 1735166124Srafan objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk); 1736166124Srafan 1737166124Srafan assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check"); 1738166124Srafan 1739166124Srafan int method = methods->short_at(chunk_index); 1740166124Srafan int version = version_at(bcis->int_at(chunk_index)); 1741166124Srafan int bci = bci_at(bcis->int_at(chunk_index)); 1742166124Srafan Handle mirror(THREAD, mirrors->obj_at(chunk_index)); 1743166124Srafan 1744166124Srafan // Chunk can be partial full 1745166124Srafan if (mirror.is_null()) { 1746166124Srafan THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); 1747166124Srafan } 1748166124Srafan 1749166124Srafan oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, CHECK_0); 1750166124Srafan return element; 1751166124Srafan} 1752166124Srafan 1753166124Srafanoop java_lang_StackTraceElement::create(Handle mirror, int method_id, int version, int bci, TRAPS) { 1754166124Srafan // Allocate java.lang.StackTraceElement instance 1755166124Srafan Klass* k = SystemDictionary::StackTraceElement_klass(); 1756166124Srafan assert(k != NULL, "must be loaded in 1.4+"); 1757166124Srafan instanceKlassHandle ik (THREAD, k); 1758166124Srafan if (ik->should_be_initialized()) { 1759166124Srafan ik->initialize(CHECK_0); 1760166124Srafan } 1761166124Srafan 1762166124Srafan Handle element = ik->allocate_instance_handle(CHECK_0); 1763166124Srafan // Fill in class name 1764166124Srafan ResourceMark rm(THREAD); 1765166124Srafan InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror())); 1766166124Srafan const char* str = holder->external_name(); 1767166124Srafan oop classname = StringTable::intern((char*) str, CHECK_0); 1768166124Srafan java_lang_StackTraceElement::set_declaringClass(element(), classname); 1769166124Srafan 1770166124Srafan // Fill in method name 1771166124Srafan Method* method = holder->method_with_idnum(method_id); 1772166124Srafan oop methodname = StringTable::intern(method->name(), CHECK_0); 1773166124Srafan java_lang_StackTraceElement::set_methodName(element(), methodname); 1774166124Srafan 1775166124Srafan if (!version_matches(method, version)) { 1776166124Srafan // The method was redefined, accurate line number information isn't available 1777166124Srafan java_lang_StackTraceElement::set_fileName(element(), NULL); 1778166124Srafan java_lang_StackTraceElement::set_lineNumber(element(), -1); 1779166124Srafan } else { 1780166124Srafan // Fill in source file name and line number. 1781166124Srafan Symbol* source = holder->source_file_name(); 1782166124Srafan if (ShowHiddenFrames && source == NULL) 1783166124Srafan source = vmSymbols::unknown_class_name(); 1784166124Srafan oop filename = StringTable::intern(source, CHECK_0); 1785166124Srafan java_lang_StackTraceElement::set_fileName(element(), filename); 1786166124Srafan 1787166124Srafan int line_number = get_line_number(method, bci); 1788166124Srafan java_lang_StackTraceElement::set_lineNumber(element(), line_number); 1789166124Srafan } 1790166124Srafan return element(); 1791166124Srafan} 1792166124Srafan 1793166124Srafanoop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) { 1794166124Srafan Handle mirror (THREAD, method->method_holder()->java_mirror()); 1795166124Srafan int method_id = method->method_idnum(); 1796166124Srafan return create(mirror, method_id, method->constants()->version(), bci, THREAD); 1797166124Srafan} 1798166124Srafan 1799166124Srafanvoid java_lang_reflect_AccessibleObject::compute_offsets() { 1800166124Srafan Klass* k = SystemDictionary::reflect_AccessibleObject_klass(); 1801166124Srafan compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); 1802166124Srafan} 1803166124Srafan 1804166124Srafanjboolean java_lang_reflect_AccessibleObject::override(oop reflect) { 1805166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1806166124Srafan return (jboolean) reflect->bool_field(override_offset); 1807166124Srafan} 1808166124Srafan 1809166124Srafanvoid java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) { 1810166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1811166124Srafan reflect->bool_field_put(override_offset, (int) value); 1812166124Srafan} 1813166124Srafan 1814166124Srafanvoid java_lang_reflect_Method::compute_offsets() { 1815166124Srafan Klass* k = SystemDictionary::reflect_Method_klass(); 1816166124Srafan compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 1817166124Srafan compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 1818166124Srafan compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); 1819166124Srafan compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); 1820166124Srafan compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); 1821166124Srafan compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); 1822166124Srafan compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 1823166124Srafan // The generic signature and annotations fields are only present in 1.5 1824166124Srafan signature_offset = -1; 1825166124Srafan annotations_offset = -1; 1826166124Srafan parameter_annotations_offset = -1; 1827166124Srafan annotation_default_offset = -1; 1828166124Srafan type_annotations_offset = -1; 1829166124Srafan compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); 1830166124Srafan compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 1831166124Srafan compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); 1832166124Srafan compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); 1833166124Srafan compute_optional_offset(type_annotations_offset, k, vmSymbols::type_annotations_name(), vmSymbols::byte_array_signature()); 1834166124Srafan} 1835166124Srafan 1836166124SrafanHandle java_lang_reflect_Method::create(TRAPS) { 1837166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1838166124Srafan Klass* klass = SystemDictionary::reflect_Method_klass(); 1839166124Srafan // This class is eagerly initialized during VM initialization, since we keep a refence 1840166124Srafan // to one of the methods 1841166124Srafan assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized"); 1842166124Srafan return InstanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); 1843166124Srafan} 1844166124Srafan 1845166124Srafanoop java_lang_reflect_Method::clazz(oop reflect) { 1846166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1847166124Srafan return reflect->obj_field(clazz_offset); 1848166124Srafan} 1849166124Srafan 1850166124Srafanvoid java_lang_reflect_Method::set_clazz(oop reflect, oop value) { 1851166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1852166124Srafan reflect->obj_field_put(clazz_offset, value); 1853166124Srafan} 1854166124Srafan 1855166124Srafanint java_lang_reflect_Method::slot(oop reflect) { 1856174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1857166124Srafan return reflect->int_field(slot_offset); 1858166124Srafan} 1859174993Srafan 1860174993Srafanvoid java_lang_reflect_Method::set_slot(oop reflect, int value) { 1861166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1862166124Srafan reflect->int_field_put(slot_offset, value); 1863174993Srafan} 1864174993Srafan 1865174993Srafanoop java_lang_reflect_Method::name(oop method) { 1866174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1867174993Srafan return method->obj_field(name_offset); 1868174993Srafan} 1869174993Srafan 1870174993Srafanvoid java_lang_reflect_Method::set_name(oop method, oop value) { 1871174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1872174993Srafan method->obj_field_put(name_offset, value); 1873174993Srafan} 1874166124Srafan 1875166124Srafanoop java_lang_reflect_Method::return_type(oop method) { 1876166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1877166124Srafan return method->obj_field(returnType_offset); 1878166124Srafan} 1879166124Srafan 1880166124Srafanvoid java_lang_reflect_Method::set_return_type(oop method, oop value) { 1881166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1882166124Srafan method->obj_field_put(returnType_offset, value); 1883166124Srafan} 1884166124Srafan 1885166124Srafanoop java_lang_reflect_Method::parameter_types(oop method) { 1886166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1887166124Srafan return method->obj_field(parameterTypes_offset); 1888166124Srafan} 1889166124Srafan 1890166124Srafanvoid java_lang_reflect_Method::set_parameter_types(oop method, oop value) { 1891184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1892166124Srafan method->obj_field_put(parameterTypes_offset, value); 1893166124Srafan} 1894166124Srafan 1895166124Srafanoop java_lang_reflect_Method::exception_types(oop method) { 1896166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1897166124Srafan return method->obj_field(exceptionTypes_offset); 1898166124Srafan} 1899184989Srafan 1900166124Srafanvoid java_lang_reflect_Method::set_exception_types(oop method, oop value) { 1901166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1902166124Srafan method->obj_field_put(exceptionTypes_offset, value); 1903166124Srafan} 1904166124Srafan 1905166124Srafanint java_lang_reflect_Method::modifiers(oop method) { 1906166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1907166124Srafan return method->int_field(modifiers_offset); 1908166124Srafan} 1909166124Srafan 1910166124Srafanvoid java_lang_reflect_Method::set_modifiers(oop method, int value) { 1911166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1912166124Srafan method->int_field_put(modifiers_offset, value); 1913166124Srafan} 1914166124Srafan 1915166124Srafanbool java_lang_reflect_Method::has_signature_field() { 1916166124Srafan return (signature_offset >= 0); 1917166124Srafan} 1918166124Srafan 1919166124Srafanoop java_lang_reflect_Method::signature(oop method) { 1920166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1921166124Srafan assert(has_signature_field(), "signature field must be present"); 1922166124Srafan return method->obj_field(signature_offset); 1923166124Srafan} 1924166124Srafan 1925166124Srafanvoid java_lang_reflect_Method::set_signature(oop method, oop value) { 1926166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1927166124Srafan assert(has_signature_field(), "signature field must be present"); 1928166124Srafan method->obj_field_put(signature_offset, value); 1929166124Srafan} 1930166124Srafan 1931166124Srafanbool java_lang_reflect_Method::has_annotations_field() { 1932166124Srafan return (annotations_offset >= 0); 1933166124Srafan} 1934166124Srafan 1935166124Srafanoop java_lang_reflect_Method::annotations(oop method) { 1936166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1937166124Srafan assert(has_annotations_field(), "annotations field must be present"); 1938166124Srafan return method->obj_field(annotations_offset); 1939166124Srafan} 1940166124Srafan 1941166124Srafanvoid java_lang_reflect_Method::set_annotations(oop method, oop value) { 1942166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1943166124Srafan assert(has_annotations_field(), "annotations field must be present"); 1944166124Srafan method->obj_field_put(annotations_offset, value); 1945166124Srafan} 1946166124Srafan 1947166124Srafanbool java_lang_reflect_Method::has_parameter_annotations_field() { 1948166124Srafan return (parameter_annotations_offset >= 0); 1949166124Srafan} 1950166124Srafan 1951166124Srafanoop java_lang_reflect_Method::parameter_annotations(oop method) { 1952166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1953166124Srafan assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 1954166124Srafan return method->obj_field(parameter_annotations_offset); 1955166124Srafan} 1956166124Srafan 1957166124Srafanvoid java_lang_reflect_Method::set_parameter_annotations(oop method, oop value) { 1958166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1959166124Srafan assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 1960166124Srafan method->obj_field_put(parameter_annotations_offset, value); 1961166124Srafan} 1962166124Srafan 1963174993Srafanbool java_lang_reflect_Method::has_annotation_default_field() { 1964166124Srafan return (annotation_default_offset >= 0); 1965166124Srafan} 1966166124Srafan 1967166124Srafanoop java_lang_reflect_Method::annotation_default(oop method) { 1968166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1969166124Srafan assert(has_annotation_default_field(), "annotation default field must be present"); 1970166124Srafan return method->obj_field(annotation_default_offset); 1971166124Srafan} 1972174993Srafan 1973166124Srafanvoid java_lang_reflect_Method::set_annotation_default(oop method, oop value) { 1974166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1975166124Srafan assert(has_annotation_default_field(), "annotation default field must be present"); 1976166124Srafan method->obj_field_put(annotation_default_offset, value); 1977166124Srafan} 1978166124Srafan 1979166124Srafanbool java_lang_reflect_Method::has_type_annotations_field() { 1980166124Srafan return (type_annotations_offset >= 0); 1981166124Srafan} 1982166124Srafan 1983166124Srafanoop java_lang_reflect_Method::type_annotations(oop method) { 1984166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1985166124Srafan assert(has_type_annotations_field(), "type_annotations field must be present"); 1986166124Srafan return method->obj_field(type_annotations_offset); 1987166124Srafan} 1988166124Srafan 1989166124Srafanvoid java_lang_reflect_Method::set_type_annotations(oop method, oop value) { 1990166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 1991166124Srafan assert(has_type_annotations_field(), "type_annotations field must be present"); 1992166124Srafan method->obj_field_put(type_annotations_offset, value); 1993166124Srafan} 1994166124Srafan 1995166124Srafanvoid java_lang_reflect_Constructor::compute_offsets() { 1996166124Srafan Klass* k = SystemDictionary::reflect_Constructor_klass(); 1997166124Srafan compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 1998166124Srafan compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); 1999166124Srafan compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); 2000166124Srafan compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); 2001184989Srafan compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 2002184989Srafan // The generic signature and annotations fields are only present in 1.5 2003184989Srafan signature_offset = -1; 2004184989Srafan annotations_offset = -1; 2005184989Srafan parameter_annotations_offset = -1; 2006184989Srafan type_annotations_offset = -1; 2007184989Srafan compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); 2008184989Srafan compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 2009184989Srafan compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); 2010184989Srafan compute_optional_offset(type_annotations_offset, k, vmSymbols::type_annotations_name(), vmSymbols::byte_array_signature()); 2011184989Srafan} 2012184989Srafan 2013184989SrafanHandle java_lang_reflect_Constructor::create(TRAPS) { 2014184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2015184989Srafan Symbol* name = vmSymbols::java_lang_reflect_Constructor(); 2016184989Srafan Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 2017184989Srafan instanceKlassHandle klass (THREAD, k); 2018184989Srafan // Ensure it is initialized 2019184989Srafan klass->initialize(CHECK_NH); 2020184989Srafan return klass->allocate_instance_handle(CHECK_NH); 2021184989Srafan} 2022166124Srafan 2023166124Srafanoop java_lang_reflect_Constructor::clazz(oop reflect) { 202450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 202550276Speter return reflect->obj_field(clazz_offset); 202650276Speter} 202750276Speter 202850276Spetervoid java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) { 2029166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2030166124Srafan reflect->obj_field_put(clazz_offset, value); 203150276Speter} 203250276Speter 203350276Speteroop java_lang_reflect_Constructor::parameter_types(oop constructor) { 203450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 203550276Speter return constructor->obj_field(parameterTypes_offset); 203650276Speter} 2037166124Srafan 203850276Spetervoid java_lang_reflect_Constructor::set_parameter_types(oop constructor, oop value) { 2039166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 204050276Speter constructor->obj_field_put(parameterTypes_offset, value); 204166963Speter} 2042166124Srafan 204350276Speteroop java_lang_reflect_Constructor::exception_types(oop constructor) { 204450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 204550276Speter return constructor->obj_field(exceptionTypes_offset); 2046166124Srafan} 204750276Speter 204850276Spetervoid java_lang_reflect_Constructor::set_exception_types(oop constructor, oop value) { 2049166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 205050276Speter constructor->obj_field_put(exceptionTypes_offset, value); 205150276Speter} 205250276Speter 205350276Speterint java_lang_reflect_Constructor::slot(oop reflect) { 205450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2055166124Srafan return reflect->int_field(slot_offset); 2056166124Srafan} 2057166124Srafan 2058166124Srafanvoid java_lang_reflect_Constructor::set_slot(oop reflect, int value) { 2059166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2060166124Srafan reflect->int_field_put(slot_offset, value); 2061166124Srafan} 2062166124Srafan 2063166124Srafanint java_lang_reflect_Constructor::modifiers(oop constructor) { 2064166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2065166124Srafan return constructor->int_field(modifiers_offset); 2066166124Srafan} 2067166124Srafan 2068166124Srafanvoid java_lang_reflect_Constructor::set_modifiers(oop constructor, int value) { 2069166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2070166124Srafan constructor->int_field_put(modifiers_offset, value); 2071166124Srafan} 2072166124Srafan 2073166124Srafanbool java_lang_reflect_Constructor::has_signature_field() { 2074166124Srafan return (signature_offset >= 0); 2075166124Srafan} 2076166124Srafan 2077166124Srafanoop java_lang_reflect_Constructor::signature(oop constructor) { 2078166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2079166124Srafan assert(has_signature_field(), "signature field must be present"); 2080166124Srafan return constructor->obj_field(signature_offset); 2081166124Srafan} 2082166124Srafan 2083166124Srafanvoid java_lang_reflect_Constructor::set_signature(oop constructor, oop value) { 2084166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2085166124Srafan assert(has_signature_field(), "signature field must be present"); 2086166124Srafan constructor->obj_field_put(signature_offset, value); 2087166124Srafan} 2088166124Srafan 2089166124Srafanbool java_lang_reflect_Constructor::has_annotations_field() { 2090166124Srafan return (annotations_offset >= 0); 2091166124Srafan} 2092166124Srafan 2093166124Srafanoop java_lang_reflect_Constructor::annotations(oop constructor) { 209450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 209550276Speter assert(has_annotations_field(), "annotations field must be present"); 209650276Speter return constructor->obj_field(annotations_offset); 209750276Speter} 209850276Speter 209950276Spetervoid java_lang_reflect_Constructor::set_annotations(oop constructor, oop value) { 210050276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 210150276Speter assert(has_annotations_field(), "annotations field must be present"); 210250276Speter constructor->obj_field_put(annotations_offset, value); 210350276Speter} 210466963Speter 210550276Speterbool java_lang_reflect_Constructor::has_parameter_annotations_field() { 210650276Speter return (parameter_annotations_offset >= 0); 2107174993Srafan} 2108166124Srafan 2109166124Srafanoop java_lang_reflect_Constructor::parameter_annotations(oop method) { 2110166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2111166124Srafan assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 2112166124Srafan return method->obj_field(parameter_annotations_offset); 2113166124Srafan} 2114166124Srafan 2115166124Srafanvoid java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) { 2116166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2117166124Srafan assert(has_parameter_annotations_field(), "parameter annotations field must be present"); 2118166124Srafan method->obj_field_put(parameter_annotations_offset, value); 2119166124Srafan} 2120166124Srafan 2121166124Srafanbool java_lang_reflect_Constructor::has_type_annotations_field() { 2122166124Srafan return (type_annotations_offset >= 0); 2123166124Srafan} 2124166124Srafan 2125174993Srafanoop java_lang_reflect_Constructor::type_annotations(oop constructor) { 2126166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2127166124Srafan assert(has_type_annotations_field(), "type_annotations field must be present"); 2128166124Srafan return constructor->obj_field(type_annotations_offset); 2129166124Srafan} 2130166124Srafan 2131166124Srafanvoid java_lang_reflect_Constructor::set_type_annotations(oop constructor, oop value) { 2132166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2133166124Srafan assert(has_type_annotations_field(), "type_annotations field must be present"); 2134166124Srafan constructor->obj_field_put(type_annotations_offset, value); 2135166124Srafan} 2136166124Srafan 2137166124Srafanvoid java_lang_reflect_Field::compute_offsets() { 2138166124Srafan Klass* k = SystemDictionary::reflect_Field_klass(); 2139166124Srafan compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); 2140166124Srafan compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 2141166124Srafan compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); 2142166124Srafan compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); 2143166124Srafan compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 2144166124Srafan // The generic signature and annotations fields are only present in 1.5 2145166124Srafan signature_offset = -1; 2146184989Srafan annotations_offset = -1; 2147174993Srafan type_annotations_offset = -1; 2148174993Srafan compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); 2149174993Srafan compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); 2150174993Srafan compute_optional_offset(type_annotations_offset, k, vmSymbols::type_annotations_name(), vmSymbols::byte_array_signature()); 2151174993Srafan} 2152174993Srafan 2153174993SrafanHandle java_lang_reflect_Field::create(TRAPS) { 2154174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2155184989Srafan Symbol* name = vmSymbols::java_lang_reflect_Field(); 2156184989Srafan Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 2157184989Srafan instanceKlassHandle klass (THREAD, k); 2158184989Srafan // Ensure it is initialized 2159184989Srafan klass->initialize(CHECK_NH); 2160184989Srafan return klass->allocate_instance_handle(CHECK_NH); 2161184989Srafan} 2162184989Srafan 2163184989Srafanoop java_lang_reflect_Field::clazz(oop reflect) { 2164184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2165174993Srafan return reflect->obj_field(clazz_offset); 2166174993Srafan} 2167174993Srafan 2168174993Srafanvoid java_lang_reflect_Field::set_clazz(oop reflect, oop value) { 2169174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2170174993Srafan reflect->obj_field_put(clazz_offset, value); 2171174993Srafan} 2172174993Srafan 2173174993Srafanoop java_lang_reflect_Field::name(oop field) { 2174174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2175174993Srafan return field->obj_field(name_offset); 2176174993Srafan} 2177174993Srafan 2178174993Srafanvoid java_lang_reflect_Field::set_name(oop field, oop value) { 2179174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2180174993Srafan field->obj_field_put(name_offset, value); 2181174993Srafan} 2182174993Srafan 2183174993Srafanoop java_lang_reflect_Field::type(oop field) { 2184174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2185174993Srafan return field->obj_field(type_offset); 2186174993Srafan} 2187174993Srafan 2188174993Srafanvoid java_lang_reflect_Field::set_type(oop field, oop value) { 2189174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2190174993Srafan field->obj_field_put(type_offset, value); 2191174993Srafan} 2192174993Srafan 2193174993Srafanint java_lang_reflect_Field::slot(oop reflect) { 2194174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2195174993Srafan return reflect->int_field(slot_offset); 2196184989Srafan} 2197184989Srafan 2198184989Srafanvoid java_lang_reflect_Field::set_slot(oop reflect, int value) { 2199184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2200184989Srafan reflect->int_field_put(slot_offset, value); 220197049Speter} 2202184989Srafan 2203166124Srafanint java_lang_reflect_Field::modifiers(oop field) { 220450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 220550276Speter return field->int_field(modifiers_offset); 220650276Speter} 220750276Speter 2208184989Srafanvoid java_lang_reflect_Field::set_modifiers(oop field, int value) { 2209184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2210184989Srafan field->int_field_put(modifiers_offset, value); 2211184989Srafan} 2212184989Srafan 2213184989Srafanbool java_lang_reflect_Field::has_signature_field() { 221450276Speter return (signature_offset >= 0); 221562449Speter} 221656639Speter 221750276Speteroop java_lang_reflect_Field::signature(oop field) { 221850276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2219184989Srafan assert(has_signature_field(), "signature field must be present"); 2220166124Srafan return field->obj_field(signature_offset); 222150276Speter} 222250276Speter 2223174993Srafanvoid java_lang_reflect_Field::set_signature(oop field, oop value) { 222450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 222550276Speter assert(has_signature_field(), "signature field must be present"); 222650276Speter field->obj_field_put(signature_offset, value); 222750276Speter} 222850276Speter 222950276Speterbool java_lang_reflect_Field::has_annotations_field() { 223050276Speter return (annotations_offset >= 0); 223150276Speter} 223250276Speter 223350276Speteroop java_lang_reflect_Field::annotations(oop field) { 223450276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 223550276Speter assert(has_annotations_field(), "annotations field must be present"); 2236184989Srafan return field->obj_field(annotations_offset); 2237184989Srafan} 2238184989Srafan 2239184989Srafanvoid java_lang_reflect_Field::set_annotations(oop field, oop value) { 2240184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2241184989Srafan assert(has_annotations_field(), "annotations field must be present"); 224250276Speter field->obj_field_put(annotations_offset, value); 224350276Speter} 2244166124Srafan 2245166124Srafanbool java_lang_reflect_Field::has_type_annotations_field() { 2246166124Srafan return (type_annotations_offset >= 0); 224750276Speter} 224897049Speter 224997049Speteroop java_lang_reflect_Field::type_annotations(oop field) { 2250166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 225150276Speter assert(has_type_annotations_field(), "type_annotations field must be present"); 2252184989Srafan return field->obj_field(type_annotations_offset); 225366963Speter} 225466963Speter 225566963Spetervoid java_lang_reflect_Field::set_type_annotations(oop field, oop value) { 225697049Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 225797049Speter assert(has_type_annotations_field(), "type_annotations field must be present"); 2258166124Srafan field->obj_field_put(type_annotations_offset, value); 2259166124Srafan} 2260166124Srafan 2261166124Srafanvoid sun_reflect_ConstantPool::compute_offsets() { 2262166124Srafan Klass* k = SystemDictionary::reflect_ConstantPool_klass(); 2263166124Srafan // This null test can be removed post beta 2264166124Srafan if (k != NULL) { 2265166124Srafan // The field is called ConstantPool* in the sun.reflect.ConstantPool class. 2266166124Srafan compute_offset(_oop_offset, k, vmSymbols::ConstantPool_name(), vmSymbols::object_signature()); 226797049Speter } 2268166124Srafan} 2269166124Srafan 2270166124Srafanvoid java_lang_reflect_Parameter::compute_offsets() { 227197049Speter Klass* k = SystemDictionary::reflect_Parameter_klass(); 227297049Speter if(NULL != k) { 227397049Speter compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); 2274166124Srafan compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); 2275166124Srafan compute_offset(index_offset, k, vmSymbols::index_name(), vmSymbols::int_signature()); 2276166124Srafan compute_offset(executable_offset, k, vmSymbols::executable_name(), vmSymbols::executable_signature()); 2277166124Srafan } 2278166124Srafan} 2279166124Srafan 2280166124SrafanHandle java_lang_reflect_Parameter::create(TRAPS) { 2281166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2282166124Srafan Symbol* name = vmSymbols::java_lang_reflect_Parameter(); 228397049Speter Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); 2284166124Srafan instanceKlassHandle klass (THREAD, k); 2285166124Srafan // Ensure it is initialized 2286166124Srafan klass->initialize(CHECK_NH); 228797049Speter return klass->allocate_instance_handle(CHECK_NH); 228866963Speter} 228966963Speter 229097049Speteroop java_lang_reflect_Parameter::name(oop param) { 2291166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2292166124Srafan return param->obj_field(name_offset); 229397049Speter} 2294184989Srafan 2295184989Srafanvoid java_lang_reflect_Parameter::set_name(oop param, oop value) { 229697049Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 229766963Speter param->obj_field_put(name_offset, value); 229897049Speter} 229997049Speter 230050276Speterint java_lang_reflect_Parameter::modifiers(oop param) { 230150276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 230250276Speter return param->int_field(modifiers_offset); 230397049Speter} 2304174993Srafan 2305184989Srafanvoid java_lang_reflect_Parameter::set_modifiers(oop param, int value) { 2306174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2307174993Srafan param->int_field_put(modifiers_offset, value); 2308174993Srafan} 2309174993Srafan 2310174993Srafanint java_lang_reflect_Parameter::index(oop param) { 2311174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2312184989Srafan return param->int_field(index_offset); 2313174993Srafan} 2314174993Srafan 2315184989Srafanvoid java_lang_reflect_Parameter::set_index(oop param, int value) { 2316174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2317174993Srafan param->int_field_put(index_offset, value); 2318184989Srafan} 2319174993Srafan 2320174993Srafanoop java_lang_reflect_Parameter::executable(oop param) { 2321174993Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2322174993Srafan return param->obj_field(executable_offset); 2323174993Srafan} 2324184989Srafan 2325184989Srafanvoid java_lang_reflect_Parameter::set_executable(oop param, oop value) { 2326184989Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2327174993Srafan param->obj_field_put(executable_offset, value); 2328174993Srafan} 2329174993Srafan 2330174993Srafan 233197049SpeterHandle sun_reflect_ConstantPool::create(TRAPS) { 2332166124Srafan assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 233350276Speter Klass* k = SystemDictionary::reflect_ConstantPool_klass(); 233450276Speter instanceKlassHandle klass (THREAD, k); 2335166124Srafan // Ensure it is initialized 2336166124Srafan klass->initialize(CHECK_NH); 233750276Speter return klass->allocate_instance_handle(CHECK_NH); 233850276Speter} 233950276Speter 234050276Speter 234197049Spetervoid sun_reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) { 234250276Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 234350276Speter oop mirror = value->pool_holder()->java_mirror(); 234497049Speter // Save the mirror to get back the constant pool. 234550276Speter reflect->obj_field_put(_oop_offset, mirror); 234697049Speter} 2347166124Srafan 234897049SpeterConstantPool* sun_reflect_ConstantPool::get_cp(oop reflect) { 234997049Speter assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); 2350166124Srafan 2351184989Srafan oop mirror = reflect->obj_field(_oop_offset); 235250276Speter Klass* k = java_lang_Class::as_Klass(mirror); 235350276Speter assert(k->oop_is_instance(), "Must be"); 2354166124Srafan 2355166124Srafan // Get the constant pool back from the klass. Since class redefinition 2356166124Srafan // merges the new constant pool into the old, this is essentially the 2357166124Srafan // same constant pool as the original. If constant pool merging is 2358166124Srafan // no longer done in the future, this will have to change to save 2359184989Srafan // the original. 2360166124Srafan return InstanceKlass::cast(k)->constants(); 2361174993Srafan} 2362166124Srafan 2363174993Srafanvoid sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { 2364174993Srafan Klass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); 2365174993Srafan // This null test can be removed post beta 2366174993Srafan if (k != NULL) { 2367166124Srafan compute_offset(_base_offset, k, 2368184989Srafan vmSymbols::base_name(), vmSymbols::object_signature()); 2369184989Srafan } 2370166124Srafan} 2371184989Srafan 2372184989Srafanoop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { 2373184989Srafan Klass* k = SystemDictionary::box_klass(type); 2374184989Srafan if (k == NULL) return NULL; 2375166124Srafan instanceKlassHandle h (THREAD, k); 237650276Speter if (!h->is_initialized()) h->initialize(CHECK_0); 237750276Speter return h->allocate_instance(THREAD); 237850276Speter} 237950276Speter 238050276Speter 238150276Speteroop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) { 2382166124Srafan oop box = initialize_and_allocate(type, CHECK_0); 238350276Speter if (box == NULL) return NULL; 238450276Speter switch (type) { 238550276Speter case T_BOOLEAN: 238650276Speter box->bool_field_put(value_offset, value->z); 238750276Speter break; 238850276Speter case T_CHAR: 238950276Speter box->char_field_put(value_offset, value->c); 239050276Speter break; 2391166124Srafan case T_FLOAT: 2392166124Srafan box->float_field_put(value_offset, value->f); 2393166124Srafan break; 2394166124Srafan case T_DOUBLE: 2395166124Srafan box->double_field_put(long_value_offset, value->d); 2396166124Srafan break; 2397166124Srafan case T_BYTE: 2398166124Srafan box->byte_field_put(value_offset, value->b); 2399166124Srafan break; 2400166124Srafan case T_SHORT: 2401166124Srafan box->short_field_put(value_offset, value->s); 2402166124Srafan break; 2403166124Srafan case T_INT: 2404166124Srafan box->int_field_put(value_offset, value->i); 240550276Speter break; 2406166124Srafan case T_LONG: 240762449Speter box->long_field_put(long_value_offset, value->j); 2408166124Srafan break; 240950276Speter default: 241050276Speter return NULL; 241150276Speter } 241250276Speter return box; 2413174993Srafan} 2414174993Srafan 241566963Speter 241697049SpeterBasicType java_lang_boxing_object::basic_type(oop box) { 2417174993Srafan if (box == NULL) return T_ILLEGAL; 241850276Speter BasicType type = SystemDictionary::box_klass_type(box->klass()); 241950276Speter if (type == T_OBJECT) // 'unknown' value returned by SD::bkt 242050276Speter return T_ILLEGAL; 242150276Speter return type; 242250276Speter} 2423166124Srafan 242450276Speter 2425166124SrafanBasicType java_lang_boxing_object::get_value(oop box, jvalue* value) { 2426166124Srafan BasicType type = SystemDictionary::box_klass_type(box->klass()); 2427166124Srafan switch (type) { 242897049Speter case T_BOOLEAN: 242997049Speter value->z = box->bool_field(value_offset); 243097049Speter break; 243197049Speter case T_CHAR: 243297049Speter value->c = box->char_field(value_offset); 243350276Speter break; 243450276Speter case T_FLOAT: 243562449Speter value->f = box->float_field(value_offset); 2436166124Srafan break; 243750276Speter case T_DOUBLE: 243850276Speter value->d = box->double_field(long_value_offset); 243950276Speter break; 244050276Speter case T_BYTE: 2441166124Srafan value->b = box->byte_field(value_offset); 2442166124Srafan break; 244350276Speter case T_SHORT: 244497049Speter value->s = box->short_field(value_offset); 244550276Speter break; 244650276Speter case T_INT: 244750276Speter value->i = box->int_field(value_offset); 244850276Speter break; 2449166124Srafan case T_LONG: 245050276Speter value->j = box->long_field(long_value_offset); 245150276Speter break; 245250276Speter default: 245350276Speter return T_ILLEGAL; 2454166124Srafan } // end switch 2455166124Srafan return type; 2456166124Srafan} 2457166124Srafan 245850276Speter 245950276SpeterBasicType java_lang_boxing_object::set_value(oop box, jvalue* value) { 246050276Speter BasicType type = SystemDictionary::box_klass_type(box->klass()); 246162449Speter switch (type) { 246250276Speter case T_BOOLEAN: 246350276Speter box->bool_field_put(value_offset, value->z); 2464166124Srafan break; 246550276Speter case T_CHAR: 246650276Speter box->char_field_put(value_offset, value->c); 246750276Speter break; 246850276Speter case T_FLOAT: 246950276Speter box->float_field_put(value_offset, value->f); 247050276Speter break; 247150276Speter case T_DOUBLE: 247250276Speter box->double_field_put(long_value_offset, value->d); 247350276Speter break; 247450276Speter case T_BYTE: 247550276Speter box->byte_field_put(value_offset, value->b); 247650276Speter break; 247750276Speter case T_SHORT: 247850276Speter box->short_field_put(value_offset, value->s); 247950276Speter break; 248050276Speter case T_INT: 248162449Speter box->int_field_put(value_offset, value->i); 248250276Speter break; 248350276Speter case T_LONG: 248450276Speter box->long_field_put(long_value_offset, value->j); 248550276Speter break; 248650276Speter default: 2487166124Srafan return T_ILLEGAL; 248850276Speter } // end switch 248950276Speter return type; 249050276Speter} 249150276Speter 249262449Speter 249350276Spetervoid java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream* st) { 249450276Speter switch (type) { 249550276Speter case T_BOOLEAN: st->print("%s", value->z ? "true" : "false"); break; 249650276Speter case T_CHAR: st->print("%d", value->c); break; 2497166124Srafan case T_BYTE: st->print("%d", value->b); break; 249850276Speter case T_SHORT: st->print("%d", value->s); break; 249950276Speter case T_INT: st->print("%d", value->i); break; 250050276Speter case T_LONG: st->print(INT64_FORMAT, value->j); break; 250150276Speter case T_FLOAT: st->print("%f", value->f); break; 250250276Speter case T_DOUBLE: st->print("%lf", value->d); break; 250350276Speter default: st->print("type %d?", type); break; 2504174993Srafan } 2505174993Srafan} 2506166124Srafan 250750276Speter 250897049Speter// Support for java_lang_ref_Reference 250956639SpeterHeapWord *java_lang_ref_Reference::pending_list_lock_addr() { 2510166124Srafan InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); 251150276Speter address addr = ik->static_field_addr(static_lock_offset); 251250276Speter return (HeapWord*) addr; 251350276Speter} 2514174993Srafan 2515166124Srafanoop java_lang_ref_Reference::pending_list_lock() { 251650276Speter InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); 251750276Speter address addr = ik->static_field_addr(static_lock_offset); 251866963Speter if (UseCompressedOops) { 251966963Speter return oopDesc::load_decode_heap_oop((narrowOop *)addr); 252066963Speter } else { 252166963Speter return oopDesc::load_decode_heap_oop((oop*)addr); 252266963Speter } 252397049Speter} 252466963Speter 2525166124SrafanHeapWord *java_lang_ref_Reference::pending_list_addr() { 252666963Speter InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); 252766963Speter address addr = ik->static_field_addr(static_pending_offset); 252866963Speter // XXX This might not be HeapWord aligned, almost rather be char *. 252966963Speter return (HeapWord*)addr; 253050276Speter} 253150276Speter 253250276Speteroop java_lang_ref_Reference::pending_list() { 253350276Speter char *addr = (char *)pending_list_addr(); 253450276Speter if (UseCompressedOops) { 253550276Speter return oopDesc::load_decode_heap_oop((narrowOop *)addr); 253650276Speter } else { 253750276Speter return oopDesc::load_decode_heap_oop((oop*)addr); 253850276Speter } 253950276Speter} 254050276Speter 254150276Speter 254250276Speter// Support for java_lang_ref_SoftReference 254350276Speter 254450276Speterjlong java_lang_ref_SoftReference::timestamp(oop ref) { 254550276Speter return ref->long_field(timestamp_offset); 254650276Speter} 254750276Speter 254850276Speterjlong java_lang_ref_SoftReference::clock() { 254950276Speter InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass()); 255050276Speter jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); 255150276Speter return *offset; 255250276Speter} 255350276Speter 255476726Spetervoid java_lang_ref_SoftReference::set_clock(jlong value) { 255576726Speter InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass()); 255650276Speter jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); 255776726Speter *offset = value; 2558166124Srafan} 255976726Speter 256076726Speter 256150276Speter// Support for java_lang_invoke_MethodHandle 256250276Speter 256362449Speterint java_lang_invoke_MethodHandle::_type_offset; 256462449Speterint java_lang_invoke_MethodHandle::_form_offset; 256562449Speter 256662449Speterint java_lang_invoke_MemberName::_clazz_offset; 256762449Speterint java_lang_invoke_MemberName::_name_offset; 256862449Speterint java_lang_invoke_MemberName::_type_offset; 256950276Speterint java_lang_invoke_MemberName::_flags_offset; 257050276Speterint java_lang_invoke_MemberName::_vmtarget_offset; 257176726Speterint java_lang_invoke_MemberName::_vmloader_offset; 257250276Speterint java_lang_invoke_MemberName::_vmindex_offset; 257350276Speter 257450276Speterint java_lang_invoke_LambdaForm::_vmentry_offset; 2575166124Srafan 257676726Spetervoid java_lang_invoke_MethodHandle::compute_offsets() { 257776726Speter Klass* klass_oop = SystemDictionary::MethodHandle_klass(); 257876726Speter if (klass_oop != NULL && EnableInvokeDynamic) { 257976726Speter compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature()); 258076726Speter compute_optional_offset(_form_offset, klass_oop, vmSymbols::form_name(), vmSymbols::java_lang_invoke_LambdaForm_signature()); 258176726Speter if (_form_offset == 0) { 258276726Speter EnableInvokeDynamic = false; 258376726Speter } 258476726Speter } 258576726Speter} 258676726Speter 258776726Spetervoid java_lang_invoke_MemberName::compute_offsets() { 258876726Speter Klass* klass_oop = SystemDictionary::MemberName_klass(); 258976726Speter if (klass_oop != NULL && EnableInvokeDynamic) { 259076726Speter compute_offset(_clazz_offset, klass_oop, vmSymbols::clazz_name(), vmSymbols::class_signature()); 259176726Speter compute_offset(_name_offset, klass_oop, vmSymbols::name_name(), vmSymbols::string_signature()); 259276726Speter compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::object_signature()); 259376726Speter compute_offset(_flags_offset, klass_oop, vmSymbols::flags_name(), vmSymbols::int_signature()); 259476726Speter MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); 259576726Speter } 259676726Speter} 259776726Speter 259876726Spetervoid java_lang_invoke_LambdaForm::compute_offsets() { 259976726Speter Klass* klass_oop = SystemDictionary::LambdaForm_klass(); 260076726Speter if (klass_oop != NULL && EnableInvokeDynamic) { 260176726Speter compute_offset(_vmentry_offset, klass_oop, vmSymbols::vmentry_name(), vmSymbols::java_lang_invoke_MemberName_signature()); 260276726Speter } 260376726Speter} 260476726Speter 260576726Speteroop java_lang_invoke_MethodHandle::type(oop mh) { 260676726Speter return mh->obj_field(_type_offset); 260776726Speter} 260876726Speter 260997049Spetervoid java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) { 261097049Speter mh->obj_field_put(_type_offset, mtype); 261197049Speter} 261276726Speter 261376726Speteroop java_lang_invoke_MethodHandle::form(oop mh) { 261476726Speter assert(_form_offset != 0, ""); 261550276Speter return mh->obj_field(_form_offset); 261650276Speter} 261750276Speter 261850276Spetervoid java_lang_invoke_MethodHandle::set_form(oop mh, oop lform) { 261950276Speter assert(_form_offset != 0, ""); 2620166124Srafan mh->obj_field_put(_form_offset, lform); 2621166124Srafan} 2622166124Srafan 2623166124Srafan/// MemberName accessors 262450276Speter 2625174993Srafanoop java_lang_invoke_MemberName::clazz(oop mname) { 2626174993Srafan assert(is_instance(mname), "wrong type"); 2627174993Srafan return mname->obj_field(_clazz_offset); 2628174993Srafan} 262950276Speter 263097049Spetervoid java_lang_invoke_MemberName::set_clazz(oop mname, oop clazz) { 263197049Speter assert(is_instance(mname), "wrong type"); 263297049Speter mname->obj_field_put(_clazz_offset, clazz); 263397049Speter} 2634166124Srafan 2635166124Srafanoop java_lang_invoke_MemberName::name(oop mname) { 263697049Speter assert(is_instance(mname), "wrong type"); 263797049Speter return mname->obj_field(_name_offset); 263897049Speter} 263997049Speter 264097049Spetervoid java_lang_invoke_MemberName::set_name(oop mname, oop name) { 264150276Speter assert(is_instance(mname), "wrong type"); 264250276Speter mname->obj_field_put(_name_offset, name); 264350276Speter} 264450276Speter 2645166124Srafanoop java_lang_invoke_MemberName::type(oop mname) { 2646166124Srafan assert(is_instance(mname), "wrong type"); 2647166124Srafan return mname->obj_field(_type_offset); 2648166124Srafan} 2649166124Srafan 2650166124Srafanvoid java_lang_invoke_MemberName::set_type(oop mname, oop type) { 2651166124Srafan assert(is_instance(mname), "wrong type"); 2652166124Srafan mname->obj_field_put(_type_offset, type); 2653166124Srafan} 2654166124Srafan 2655166124Srafanint java_lang_invoke_MemberName::flags(oop mname) { 2656166124Srafan assert(is_instance(mname), "wrong type"); 2657166124Srafan return mname->int_field(_flags_offset); 2658166124Srafan} 2659166124Srafan 2660166124Srafanvoid java_lang_invoke_MemberName::set_flags(oop mname, int flags) { 2661166124Srafan assert(is_instance(mname), "wrong type"); 2662166124Srafan mname->int_field_put(_flags_offset, flags); 2663166124Srafan} 2664166124Srafan 2665166124SrafanMetadata* java_lang_invoke_MemberName::vmtarget(oop mname) { 2666166124Srafan assert(is_instance(mname), "wrong type"); 2667166124Srafan return (Metadata*)mname->address_field(_vmtarget_offset); 2668166124Srafan} 2669166124Srafan 2670166124Srafan#if INCLUDE_JVMTI 2671166124Srafan// Can be executed on VM thread only 2672166124Srafanvoid java_lang_invoke_MemberName::adjust_vmtarget(oop mname, Metadata* ref) { 2673166124Srafan assert((is_instance(mname) && (flags(mname) & (MN_IS_METHOD | MN_IS_CONSTRUCTOR)) > 0), "wrong type"); 2674166124Srafan assert(Thread::current()->is_VM_thread(), "not VM thread"); 2675166124Srafan mname->address_field_put(_vmtarget_offset, (address)ref); 2676166124Srafan} 2677166124Srafan#endif // INCLUDE_JVMTI 2678166124Srafan 2679166124Srafanvoid java_lang_invoke_MemberName::set_vmtarget(oop mname, Metadata* ref) { 2680166124Srafan assert(is_instance(mname), "wrong type"); 2681166124Srafan // check the type of the vmtarget 2682184989Srafan oop dependency = NULL; 2683166124Srafan if (ref != NULL) { 268462449Speter switch (flags(mname) & (MN_IS_METHOD | 268550276Speter MN_IS_CONSTRUCTOR | 2686184989Srafan MN_IS_FIELD)) { 2687184989Srafan case MN_IS_METHOD: 268862449Speter case MN_IS_CONSTRUCTOR: 268950276Speter assert(ref->is_method(), "should be a method"); 269050276Speter dependency = ((Method*)ref)->method_holder()->java_mirror(); 269150276Speter break; 269250276Speter case MN_IS_FIELD: 2693184989Srafan assert(ref->is_klass(), "should be a class"); 2694184989Srafan dependency = ((Klass*)ref)->java_mirror(); 2695184989Srafan break; 2696184989Srafan default: 2697184989Srafan ShouldNotReachHere(); 2698184989Srafan } 2699184989Srafan } 2700184989Srafan mname->address_field_put(_vmtarget_offset, (address)ref); 2701184989Srafan // Add a reference to the loader (actually mirror because anonymous classes will not have 2702184989Srafan // distinct loaders) to ensure the metadata is kept alive 2703184989Srafan // This mirror may be different than the one in clazz field. 2704184989Srafan mname->obj_field_put(_vmloader_offset, dependency); 2705184989Srafan} 2706184989Srafan 2707184989Srafanintptr_t java_lang_invoke_MemberName::vmindex(oop mname) { 2708184989Srafan assert(is_instance(mname), "wrong type"); 270950276Speter return (intptr_t) mname->address_field(_vmindex_offset); 271050276Speter} 2711184989Srafan 2712184989Srafanvoid java_lang_invoke_MemberName::set_vmindex(oop mname, intptr_t index) { 2713184989Srafan assert(is_instance(mname), "wrong type"); 2714184989Srafan mname->address_field_put(_vmindex_offset, (address) index); 2715184989Srafan} 2716184989Srafan 2717184989Srafanoop java_lang_invoke_LambdaForm::vmentry(oop lform) { 2718184989Srafan assert(is_instance(lform), "wrong type"); 2719166124Srafan return lform->obj_field(_vmentry_offset); 2720166124Srafan} 2721184989Srafan 2722184989Srafan 2723184989Srafan// Support for java_lang_invoke_MethodType 2724184989Srafan 2725184989Srafanint java_lang_invoke_MethodType::_rtype_offset; 2726184989Srafanint java_lang_invoke_MethodType::_ptypes_offset; 2727184989Srafan 2728184989Srafanvoid java_lang_invoke_MethodType::compute_offsets() { 2729166124Srafan Klass* k = SystemDictionary::MethodType_klass(); 2730166124Srafan if (k != NULL) { 2731184989Srafan compute_offset(_rtype_offset, k, vmSymbols::rtype_name(), vmSymbols::class_signature()); 2732184989Srafan compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature()); 2733184989Srafan } 273450276Speter} 273550276Speter 273662449Spetervoid java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) { 2737184989Srafan st->print("("); 273850276Speter objArrayOop pts = ptypes(mt); 273950276Speter for (int i = 0, limit = pts->length(); i < limit; i++) { 2740166124Srafan java_lang_Class::print_signature(pts->obj_at(i), st); 2741166124Srafan } 274250276Speter st->print(")"); 274362449Speter java_lang_Class::print_signature(rtype(mt), st); 274462449Speter} 274562449Speter 274650276SpeterSymbol* java_lang_invoke_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) { 274750276Speter ResourceMark rm; 274850276Speter stringStream buffer(128); 274976726Speter print_signature(mt, &buffer); 275050276Speter const char* sigstr = buffer.base(); 275150276Speter int siglen = (int) buffer.size(); 275250276Speter Symbol *name; 275350276Speter if (!intern_if_not_found) { 275450276Speter name = SymbolTable::probe(sigstr, siglen); 275562449Speter } else { 275650276Speter name = SymbolTable::new_symbol(sigstr, siglen, THREAD); 275750276Speter } 2758166124Srafan return name; 2759166124Srafan} 276050276Speter 276150276Speterbool java_lang_invoke_MethodType::equals(oop mt1, oop mt2) { 276250276Speter if (mt1 == mt2) 276350276Speter return true; 276450276Speter if (rtype(mt1) != rtype(mt2)) 276550276Speter return false; 276650276Speter if (ptype_count(mt1) != ptype_count(mt2)) 276750276Speter return false; 276850276Speter for (int i = ptype_count(mt1) - 1; i >= 0; i--) { 276950276Speter if (ptype(mt1, i) != ptype(mt2, i)) 277050276Speter return false; 277176726Speter } 277250276Speter return true; 277350276Speter} 277450276Speter 2775166124Srafanoop java_lang_invoke_MethodType::rtype(oop mt) { 277650276Speter assert(is_instance(mt), "must be a MethodType"); 277750276Speter return mt->obj_field(_rtype_offset); 277850276Speter} 277950276Speter 278050276SpeterobjArrayOop java_lang_invoke_MethodType::ptypes(oop mt) { 278150276Speter assert(is_instance(mt), "must be a MethodType"); 278250276Speter return (objArrayOop) mt->obj_field(_ptypes_offset); 2783166124Srafan} 278450276Speter 278576726Speteroop java_lang_invoke_MethodType::ptype(oop mt, int idx) { 278676726Speter return ptypes(mt)->obj_at(idx); 278776726Speter} 278876726Speter 278950276Speterint java_lang_invoke_MethodType::ptype_count(oop mt) { 279050276Speter return ptypes(mt)->length(); 279150276Speter} 279250276Speter 279350276Speterint java_lang_invoke_MethodType::ptype_slot_count(oop mt) { 2794166124Srafan objArrayOop pts = ptypes(mt); 279550276Speter int count = pts->length(); 279650276Speter int slots = 0; 2797166124Srafan for (int i = 0; i < count; i++) { 279850276Speter BasicType bt = java_lang_Class::as_BasicType(pts->obj_at(i)); 279950276Speter slots += type2size[bt]; 280050276Speter } 280150276Speter return slots; 280250276Speter} 280350276Speter 2804166124Srafanint java_lang_invoke_MethodType::rtype_slot_count(oop mt) { 280550276Speter BasicType bt = java_lang_Class::as_BasicType(rtype(mt)); 280650276Speter return type2size[bt]; 280750276Speter} 280850276Speter 280950276Speter 281050276Speter// Support for java_lang_invoke_CallSite 281150276Speter 281250276Speterint java_lang_invoke_CallSite::_target_offset; 281397049Speter 281497049Spetervoid java_lang_invoke_CallSite::compute_offsets() { 281597049Speter if (!EnableInvokeDynamic) return; 281697049Speter Klass* k = SystemDictionary::CallSite_klass(); 281797049Speter if (k != NULL) { 281897049Speter compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature()); 281950276Speter } 282050276Speter} 2821166124Srafan 2822166124Srafan 282350276Speter// Support for java_security_AccessControlContext 282450276Speter 282550276Speterint java_security_AccessControlContext::_context_offset = 0; 282650276Speterint java_security_AccessControlContext::_privilegedContext_offset = 0; 282750276Speterint java_security_AccessControlContext::_isPrivileged_offset = 0; 282850276Speter 282950276Spetervoid java_security_AccessControlContext::compute_offsets() { 283050276Speter assert(_isPrivileged_offset == 0, "offsets should be initialized only once"); 283150276Speter fieldDescriptor fd; 2832166124Srafan InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass()); 283350276Speter 283450276Speter if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) { 283550276Speter fatal("Invalid layout of java.security.AccessControlContext"); 283650276Speter } 283750276Speter _context_offset = fd.offset(); 283850276Speter 283950276Speter if (!ik->find_local_field(vmSymbols::privilegedContext_name(), vmSymbols::accesscontrolcontext_signature(), &fd)) { 284050276Speter fatal("Invalid layout of java.security.AccessControlContext"); 284150276Speter } 284250276Speter _privilegedContext_offset = fd.offset(); 284350276Speter 284450276Speter if (!ik->find_local_field(vmSymbols::isPrivileged_name(), vmSymbols::bool_signature(), &fd)) { 284550276Speter fatal("Invalid layout of java.security.AccessControlContext"); 284650276Speter } 284750276Speter _isPrivileged_offset = fd.offset(); 284850276Speter} 284950276Speter 285050276Speter 285150276Speteroop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) { 285250276Speter assert(_isPrivileged_offset != 0, "offsets should have been initialized"); 285350276Speter // Ensure klass is initialized 285450276Speter InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); 285550276Speter // Allocate result 285650276Speter oop result = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); 285750276Speter // Fill in values 285850276Speter result->obj_field_put(_context_offset, context()); 285950276Speter result->obj_field_put(_privilegedContext_offset, privileged_context()); 286050276Speter result->bool_field_put(_isPrivileged_offset, isPrivileged); 286150276Speter return result; 286250276Speter} 2863166124Srafan 286450276Speter 286550276Speter// Support for java_lang_ClassLoader 286650276Speter 286766963Speterbool java_lang_ClassLoader::offsets_computed = false; 286850276Speterint java_lang_ClassLoader::_loader_data_offset = -1; 286950276Speterint java_lang_ClassLoader::parallelCapable_offset = -1; 287050276Speter 287150276SpeterClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) { 287250276Speter assert(loader != NULL && loader->is_oop(), "loader must be oop"); 287366963Speter return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset); 287466963Speter} 287550276Speter 287650276SpeterClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) { 287750276Speter return *java_lang_ClassLoader::loader_data_addr(loader); 2878166124Srafan} 2879166124Srafan 2880166124Srafanvoid java_lang_ClassLoader::compute_offsets() { 2881166124Srafan assert(!offsets_computed, "offsets should be initialized only once"); 2882166124Srafan offsets_computed = true; 2883166124Srafan 2884166124Srafan // The field indicating parallelCapable (parallelLockMap) is only present starting in 7, 2885166124Srafan Klass* k1 = SystemDictionary::ClassLoader_klass(); 2886166124Srafan compute_optional_offset(parallelCapable_offset, 2887166124Srafan k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature()); 2888166124Srafan 2889166124Srafan CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); 2890166124Srafan} 2891166124Srafan 2892166124Srafanoop java_lang_ClassLoader::parent(oop loader) { 289350276Speter assert(is_instance(loader), "loader must be oop"); 289450276Speter return loader->obj_field(parent_offset); 2895166124Srafan} 289650276Speter 289750276Speterbool java_lang_ClassLoader::isAncestor(oop loader, oop cl) { 289897049Speter assert(is_instance(loader), "loader must be oop"); 289950276Speter assert(cl == NULL || is_instance(cl), "cl argument must be oop"); 2900166124Srafan oop acl = loader; 290150276Speter debug_only(jint loop_count = 0); 290250276Speter // This loop taken verbatim from ClassLoader.java: 290397049Speter do { 290450276Speter acl = parent(acl); 290550276Speter if (cl == acl) { 290650276Speter return true; 2907166124Srafan } 290850276Speter assert(++loop_count > 0, "loop_count overflow"); 290950276Speter } while (acl != NULL); 291050276Speter return false; 291150276Speter} 291250276Speter 291350276Speter 291450276Speter// For class loader classes, parallelCapable defined 291550276Speter// based on non-null field 291650276Speter// Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it 291750276Speterbool java_lang_ClassLoader::parallelCapable(oop class_loader) { 291850276Speter if (!JDK_Version::is_gte_jdk17x_version() 2919166124Srafan || parallelCapable_offset == -1) { 2920166124Srafan // Default for backward compatibility is false 292150276Speter return false; 292250276Speter } 292350276Speter return (class_loader->obj_field(parallelCapable_offset) != NULL); 292497049Speter} 292597049Speter 292697049Speterbool java_lang_ClassLoader::is_trusted_loader(oop loader) { 292750276Speter // Fix for 4474172; see evaluation for more details 292850276Speter loader = non_reflection_class_loader(loader); 292950276Speter 2930166124Srafan oop cl = SystemDictionary::java_system_loader(); 2931166124Srafan while(cl != NULL) { 293266963Speter if (cl == loader) return true; 293366963Speter cl = parent(cl); 293466963Speter } 293566963Speter return false; 293666963Speter} 293766963Speter 293866963Speteroop java_lang_ClassLoader::non_reflection_class_loader(oop loader) { 293966963Speter if (loader != NULL) { 294066963Speter // See whether this is one of the class loaders associated with 294166963Speter // the generated bytecodes for reflection, and if so, "magically" 294266963Speter // delegate to its parent to prevent class loading from occurring 294366963Speter // in places where applications using reflection didn't expect it. 294466963Speter Klass* delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass(); 294566963Speter // This might be null in non-1.4 JDKs 294666963Speter if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) { 294766963Speter return parent(loader); 294866963Speter } 294966963Speter } 295066963Speter return loader; 295166963Speter} 295266963Speter 295366963Speter 295466963Speter// Support for java_lang_System 295566963Speterint java_lang_System::in_offset_in_bytes() { 295666963Speter return (InstanceMirrorKlass::offset_of_static_fields() + static_in_offset); 295766963Speter} 295866963Speter 2959166124Srafan 2960166124Srafanint java_lang_System::out_offset_in_bytes() { 296150276Speter return (InstanceMirrorKlass::offset_of_static_fields() + static_out_offset); 2962166124Srafan} 2963166124Srafan 2964166124Srafan 2965166124Srafanint java_lang_System::err_offset_in_bytes() { 2966166124Srafan return (InstanceMirrorKlass::offset_of_static_fields() + static_err_offset); 2967166124Srafan} 2968166124Srafan 2969166124Srafan 2970166124Srafan 2971166124Srafanint java_lang_Class::_klass_offset; 2972166124Srafanint java_lang_Class::_array_klass_offset; 297350276Speterint java_lang_Class::_oop_size_offset; 297476726Speterint java_lang_Class::_static_oop_field_count_offset; 297576726Speterint java_lang_Class::_protection_domain_offset; 297676726Speterint java_lang_Class::_init_lock_offset; 297750276Speterint java_lang_Class::_signers_offset; 297850276SpeterGrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL; 297950276Speterint java_lang_Throwable::backtrace_offset; 2980166124Srafanint java_lang_Throwable::detailMessage_offset; 298197049Speterint java_lang_Throwable::cause_offset; 298297049Speterint java_lang_Throwable::stackTrace_offset; 298350276Speterint java_lang_Throwable::static_unassigned_stacktrace_offset; 2984166124Srafanint java_lang_reflect_AccessibleObject::override_offset; 2985166124Srafanint java_lang_reflect_Method::clazz_offset; 2986166124Srafanint java_lang_reflect_Method::name_offset; 2987166124Srafanint java_lang_reflect_Method::returnType_offset; 2988166124Srafanint java_lang_reflect_Method::parameterTypes_offset; 2989166124Srafanint java_lang_reflect_Method::exceptionTypes_offset; 2990166124Srafanint java_lang_reflect_Method::slot_offset; 299150276Speterint java_lang_reflect_Method::modifiers_offset; 299250276Speterint java_lang_reflect_Method::signature_offset; 299350276Speterint java_lang_reflect_Method::annotations_offset; 2994166124Srafanint java_lang_reflect_Method::parameter_annotations_offset; 299550276Speterint java_lang_reflect_Method::annotation_default_offset; 2996166124Srafanint java_lang_reflect_Method::type_annotations_offset; 2997166124Srafanint java_lang_reflect_Constructor::clazz_offset; 2998166124Srafanint java_lang_reflect_Constructor::parameterTypes_offset; 2999166124Srafanint java_lang_reflect_Constructor::exceptionTypes_offset; 3000166124Srafanint java_lang_reflect_Constructor::slot_offset; 300176726Speterint java_lang_reflect_Constructor::modifiers_offset; 300250276Speterint java_lang_reflect_Constructor::signature_offset; 300350276Speterint java_lang_reflect_Constructor::annotations_offset; 3004166124Srafanint java_lang_reflect_Constructor::parameter_annotations_offset; 300550276Speterint java_lang_reflect_Constructor::type_annotations_offset; 3006166124Srafanint java_lang_reflect_Field::clazz_offset; 3007166124Srafanint java_lang_reflect_Field::name_offset; 3008166124Srafanint java_lang_reflect_Field::type_offset; 3009166124Srafanint java_lang_reflect_Field::slot_offset; 3010166124Srafanint java_lang_reflect_Field::modifiers_offset; 3011166124Srafanint java_lang_reflect_Field::signature_offset; 3012166124Srafanint java_lang_reflect_Field::annotations_offset; 3013166124Srafanint java_lang_reflect_Field::type_annotations_offset; 3014166124Srafanint java_lang_reflect_Parameter::name_offset; 3015166124Srafanint java_lang_reflect_Parameter::modifiers_offset; 3016166124Srafanint java_lang_reflect_Parameter::index_offset; 3017166124Srafanint java_lang_reflect_Parameter::executable_offset; 3018166124Srafanint java_lang_boxing_object::value_offset; 3019166124Srafanint java_lang_boxing_object::long_value_offset; 3020166124Srafanint java_lang_ref_Reference::referent_offset; 3021166124Srafanint java_lang_ref_Reference::queue_offset; 3022166124Srafanint java_lang_ref_Reference::next_offset; 3023166124Srafanint java_lang_ref_Reference::discovered_offset; 3024166124Srafanint java_lang_ref_Reference::static_lock_offset; 3025166124Srafanint java_lang_ref_Reference::static_pending_offset; 3026166124Srafanint java_lang_ref_Reference::number_of_fake_oop_fields; 3027166124Srafanint java_lang_ref_SoftReference::timestamp_offset; 3028166124Srafanint java_lang_ref_SoftReference::static_clock_offset; 3029166124Srafanint java_lang_ClassLoader::parent_offset; 3030166124Srafanint java_lang_System::static_in_offset; 3031166124Srafanint java_lang_System::static_out_offset; 3032166124Srafanint java_lang_System::static_err_offset; 3033166124Srafanint java_lang_StackTraceElement::declaringClass_offset; 3034166124Srafanint java_lang_StackTraceElement::methodName_offset; 3035166124Srafanint java_lang_StackTraceElement::fileName_offset; 3036166124Srafanint java_lang_StackTraceElement::lineNumber_offset; 3037166124Srafanint java_lang_AssertionStatusDirectives::classes_offset; 3038166124Srafanint java_lang_AssertionStatusDirectives::classEnabled_offset; 303950276Speterint java_lang_AssertionStatusDirectives::packages_offset; 3040166124Srafanint java_lang_AssertionStatusDirectives::packageEnabled_offset; 3041166124Srafanint java_lang_AssertionStatusDirectives::deflt_offset; 304250276Speterint java_nio_Buffer::_limit_offset; 304350276Speterint java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0; 304450276Speterint sun_reflect_ConstantPool::_oop_offset; 3045166124Srafanint sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset; 3046166124Srafan 304750276Speter 304850276Speter// Support for java_lang_StackTraceElement 3049166124Srafan 3050166124Srafanvoid java_lang_StackTraceElement::set_fileName(oop element, oop value) { 3051166124Srafan element->obj_field_put(fileName_offset, value); 3052166124Srafan} 3053166124Srafan 3054166124Srafanvoid java_lang_StackTraceElement::set_declaringClass(oop element, oop value) { 3055166124Srafan element->obj_field_put(declaringClass_offset, value); 3056166124Srafan} 3057166124Srafan 3058166124Srafanvoid java_lang_StackTraceElement::set_methodName(oop element, oop value) { 305950276Speter element->obj_field_put(methodName_offset, value); 306050276Speter} 306150276Speter 306297049Spetervoid java_lang_StackTraceElement::set_lineNumber(oop element, int value) { 3063166124Srafan element->int_field_put(lineNumber_offset, value); 3064166124Srafan} 3065166124Srafan 306650276Speter 306750276Speter// Support for java Assertions - java_lang_AssertionStatusDirectives. 3068166124Srafan 3069166124Srafanvoid java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) { 307050276Speter o->obj_field_put(classes_offset, val); 307150276Speter} 307250276Speter 307350276Spetervoid java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) { 307450276Speter o->obj_field_put(classEnabled_offset, val); 307550276Speter} 307650276Speter 307750276Spetervoid java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) { 307850276Speter o->obj_field_put(packages_offset, val); 307997049Speter} 308097049Speter 308150276Spetervoid java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) { 308297049Speter o->obj_field_put(packageEnabled_offset, val); 308350276Speter} 308450276Speter 308550276Spetervoid java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) { 308650276Speter o->bool_field_put(deflt_offset, val); 308750276Speter} 308897049Speter 308950276Speter 309097049Speter// Support for intrinsification of java.nio.Buffer.checkIndex 309150276Speterint java_nio_Buffer::limit_offset() { 309250276Speter return _limit_offset; 309350276Speter} 309450276Speter 309597049Speter 309697049Spetervoid java_nio_Buffer::compute_offsets() { 309797049Speter Klass* k = SystemDictionary::nio_Buffer_klass(); 309897049Speter assert(k != NULL, "must be loaded in 1.4+"); 309997049Speter compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); 310050276Speter} 310150276Speter 310250276Spetervoid java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { 310350276Speter if (_owner_offset != 0) return; 310450276Speter 310597049Speter assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); 310650276Speter SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); 3107166124Srafan Klass* k = SystemDictionary::abstract_ownable_synchronizer_klass(); 310850276Speter compute_offset(_owner_offset, k, 310950276Speter vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); 311050276Speter} 311197049Speter 311297049Speteroop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { 311350276Speter assert(_owner_offset != 0, "Must be initialized"); 311450276Speter return obj->obj_field(_owner_offset); 3115166124Srafan} 3116166124Srafan 311762449Speter// Compute hard-coded offsets 311862449Speter// Invoked before SystemDictionary::initialize, so pre-loaded classes 311962449Speter// are not available to determine the offset_of_static_fields. 312062449Spetervoid JavaClasses::compute_hard_coded_offsets() { 312162449Speter const int x = heapOopSize; 3122166124Srafan const int header = instanceOopDesc::base_offset_in_bytes(); 312362449Speter 3124166124Srafan // Throwable Class 3125166124Srafan java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header; 3126166124Srafan java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header; 3127166124Srafan java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header; 3128166124Srafan java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header; 3129166124Srafan java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset * x; 3130166124Srafan 3131166124Srafan // java_lang_boxing_object 3132166124Srafan java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header; 3133166124Srafan java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong); 3134166124Srafan 3135166124Srafan // java_lang_ref_Reference: 3136166124Srafan java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header; 3137166124Srafan java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header; 3138166124Srafan java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header; 3139166124Srafan java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header; 3140166124Srafan java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x; 314162449Speter java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x; 3142166124Srafan // Artificial fields for java_lang_ref_Reference 314397049Speter // The first field is for the discovered field added in 1.4 3144166124Srafan java_lang_ref_Reference::number_of_fake_oop_fields = 1; 314562449Speter 3146166124Srafan // java_lang_ref_SoftReference Class 3147166124Srafan java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong); 3148166124Srafan // Don't multiply static fields because they are always in wordSize units 3149166124Srafan java_lang_ref_SoftReference::static_clock_offset = java_lang_ref_SoftReference::hc_static_clock_offset * x; 3150166124Srafan 3151166124Srafan // java_lang_ClassLoader 3152166124Srafan java_lang_ClassLoader::parent_offset = java_lang_ClassLoader::hc_parent_offset * x + header; 315397049Speter 3154166124Srafan // java_lang_System 3155166124Srafan java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x; 315662449Speter java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x; 315762449Speter java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x; 3158166124Srafan 3159166124Srafan // java_lang_StackTraceElement 316076726Speter java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header; 316176726Speter java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header; 316276726Speter java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header; 316376726Speter java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header; 316476726Speter java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header; 316576726Speter java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header; 316676726Speter java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header; 316776726Speter java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header; 316897049Speter java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header; 316997049Speter 317076726Speter} 317197049Speter 317276726Speter 317376726Speter// Compute non-hard-coded field offsets of all the classes in this file 3174174993Srafanvoid JavaClasses::compute_offsets() { 3175166124Srafan // java_lang_Class::compute_offsets was called earlier in bootstrap 317650276Speter java_lang_ClassLoader::compute_offsets(); 317750276Speter java_lang_Thread::compute_offsets(); 317850276Speter java_lang_ThreadGroup::compute_offsets(); 317950276Speter if (EnableInvokeDynamic) { 318050276Speter java_lang_invoke_MethodHandle::compute_offsets(); 318150276Speter java_lang_invoke_MemberName::compute_offsets(); 318250276Speter java_lang_invoke_LambdaForm::compute_offsets(); 318350276Speter java_lang_invoke_MethodType::compute_offsets(); 318462449Speter java_lang_invoke_CallSite::compute_offsets(); 318576726Speter } 318650276Speter java_security_AccessControlContext::compute_offsets(); 318750276Speter // Initialize reflection classes. The layouts of these classes 318850276Speter // changed with the new reflection implementation in JDK 1.4, and 318950276Speter // since the Universe doesn't know what JDK version it is until this 319050276Speter // point we defer computation of these offsets until now. 319150276Speter java_lang_reflect_AccessibleObject::compute_offsets(); 319250276Speter java_lang_reflect_Method::compute_offsets(); 319397049Speter java_lang_reflect_Constructor::compute_offsets(); 3194166124Srafan java_lang_reflect_Field::compute_offsets(); 3195166124Srafan if (JDK_Version::is_gte_jdk14x_version()) { 3196166124Srafan java_nio_Buffer::compute_offsets(); 3197166124Srafan } 319850276Speter if (JDK_Version::is_gte_jdk15x_version()) { 319950276Speter sun_reflect_ConstantPool::compute_offsets(); 3200166124Srafan sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets(); 320150276Speter } 320250276Speter if (JDK_Version::is_jdk18x_version()) 320350276Speter java_lang_reflect_Parameter::compute_offsets(); 3204166124Srafan 320550276Speter // generated interpreter code wants to know about the offsets we just computed: 320650276Speter AbstractAssembler::update_delayed_values(); 320750276Speter} 320850276Speter 3209166124Srafan#ifndef PRODUCT 3210166124Srafan 3211166124Srafan// These functions exist to assert the validity of hard-coded field offsets to guard 3212166124Srafan// against changes in the class files 3213166124Srafan 3214166124Srafanbool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { 3215166124Srafan EXCEPTION_MARK; 3216166124Srafan fieldDescriptor fd; 3217166124Srafan TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); 3218166124Srafan Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 3219166124Srafan instanceKlassHandle h_klass (THREAD, k); 3220166124Srafan TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); 3221166124Srafan TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); 3222166124Srafan if (!h_klass->find_local_field(f_name, f_sig, &fd)) { 3223166124Srafan tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name); 3224174993Srafan return false; 3225166124Srafan } 3226166124Srafan if (fd.is_static()) { 322750276Speter tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name); 3228166124Srafan return false; 3229166124Srafan } 323050276Speter if (fd.offset() == hardcoded_offset ) { 323150276Speter return true; 3232166124Srafan } else { 3233166124Srafan tty->print_cr("Offset of nonstatic field %s.%s is hardcoded as %d but should really be %d.", 3234166124Srafan klass_name, field_name, hardcoded_offset, fd.offset()); 3235166124Srafan return false; 3236166124Srafan } 323797049Speter} 323866963Speter 3239166124Srafan 3240174993Srafanbool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { 3241166124Srafan EXCEPTION_MARK; 324250276Speter fieldDescriptor fd; 324350276Speter TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); 3244166124Srafan Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 324566963Speter instanceKlassHandle h_klass (THREAD, k); 324662449Speter TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); 324750276Speter TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); 324850276Speter if (!h_klass->find_local_field(f_name, f_sig, &fd)) { 324950276Speter tty->print_cr("Static field %s.%s not found", klass_name, field_name); 3250166124Srafan return false; 3251166124Srafan } 3252166124Srafan if (!fd.is_static()) { 325376726Speter tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name); 3254166124Srafan return false; 325550276Speter } 325676726Speter if (fd.offset() == hardcoded_offset + InstanceMirrorKlass::offset_of_static_fields()) { 3257166124Srafan return true; 325850276Speter } else { 325976726Speter 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()); 3260166124Srafan return false; 3261166124Srafan } 326262449Speter} 3263166124Srafan 3264166124Srafan 3265166124Srafanbool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { 3266166124Srafan EXCEPTION_MARK; 3267166124Srafan fieldDescriptor fd; 3268166124Srafan TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); 3269166124Srafan Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); 3270166124Srafan instanceKlassHandle h_klass (THREAD, k); 3271166124Srafan TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); 3272166124Srafan TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); 3273166124Srafan if (!h_klass->find_local_field(f_name, f_sig, &fd)) { 3274166124Srafan tty->print_cr("Static field %s.%s not found", klass_name, field_name); 3275166124Srafan return false; 3276166124Srafan } 3277166124Srafan if (!fd.is_static() || !fd.has_initial_value()) { 327876726Speter tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name); 327950276Speter return false; 328050276Speter } 328176726Speter if (!fd.initial_value_tag().is_int()) { 328276726Speter tty->print_cr("Static field %s.%s is not an int", klass_name, field_name); 328350276Speter return false; 3284166124Srafan } 3285166124Srafan jint field_value = fd.int_initial_value(); 328650276Speter if (field_value == hardcoded_constant) { 328750276Speter return true; 3288174993Srafan } else { 3289174993Srafan 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); 3290174993Srafan return false; 3291174993Srafan } 3292174993Srafan} 3293174993Srafan 3294174993Srafan 3295174993Srafan// Check the hard-coded field offsets of all the classes in this file 3296174993Srafan 3297174993Srafanvoid JavaClasses::check_offsets() { 3298174993Srafan bool valid = true; 3299174993Srafan HandleMark hm; 3300174993Srafan 3301174993Srafan#define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ 3302174993Srafan valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) 3303174993Srafan 3304174993Srafan#define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ 3305174993Srafan valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig) 3306174993Srafan 3307174993Srafan#define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ 3308174993Srafan valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig) 3309174993Srafan 3310174993Srafan#define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \ 3311174993Srafan valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig) 3312174993Srafan 3313174993Srafan // java.lang.String 331462449Speter 3315166124Srafan CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C"); 3316166124Srafan if (java_lang_String::has_offset_field()) { 331766963Speter CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I"); 331866963Speter CHECK_OFFSET("java/lang/String", java_lang_String, count, "I"); 3319166124Srafan } 332066963Speter if (java_lang_String::has_hash_field()) { 332166963Speter CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I"); 332250276Speter } 3323166124Srafan 3324166124Srafan // java.lang.Class 3325166124Srafan 3326174993Srafan // Fake fields 332762449Speter // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked 332862449Speter // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked 332976726Speter 333097049Speter // java.lang.Throwable 3331166124Srafan 333266963Speter CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;"); 333366963Speter CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;"); 3334166124Srafan CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;"); 333566963Speter CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;"); 3336166124Srafan 333766963Speter // Boxed primitive objects (java_lang_boxing_object) 333876726Speter 333976726Speter CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z"); 3340166124Srafan CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C"); 3341166124Srafan CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F"); 3342166124Srafan CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D"); 3343166124Srafan CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B"); 3344166124Srafan CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S"); 334576726Speter CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I"); 3346166124Srafan CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J"); 3347174993Srafan 334876726Speter // java.lang.ClassLoader 334976726Speter 335066963Speter CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;"); 3351166124Srafan 3352174993Srafan // java.lang.System 335366963Speter 3354166124Srafan CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;"); 335597049Speter CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;"); 3356166124Srafan CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, err, "Ljava/io/PrintStream;"); 3357166124Srafan 335897049Speter // java.lang.StackTraceElement 335997049Speter 3360166124Srafan CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, declaringClass, "Ljava/lang/String;"); 336166963Speter CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, methodName, "Ljava/lang/String;"); 336266963Speter CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, fileName, "Ljava/lang/String;"); 336397049Speter CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, lineNumber, "I"); 3364166124Srafan 3365166124Srafan // java.lang.ref.Reference 3366166124Srafan 336776726Speter CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, referent, "Ljava/lang/Object;"); 336876726Speter CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, queue, "Ljava/lang/ref/ReferenceQueue;"); 3369166124Srafan CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, next, "Ljava/lang/ref/Reference;"); 337050276Speter // Fake field 3371166124Srafan //CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, discovered, "Ljava/lang/ref/Reference;"); 337276726Speter CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, lock, "Ljava/lang/ref/Reference$Lock;"); 3373166124Srafan CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, pending, "Ljava/lang/ref/Reference;"); 337476726Speter 337576726Speter // java.lang.ref.SoftReference 337676726Speter 337776726Speter CHECK_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, timestamp, "J"); 3378166124Srafan CHECK_STATIC_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, clock, "J"); 3379166124Srafan 3380166124Srafan // java.lang.AssertionStatusDirectives 3381166124Srafan // 3382166124Srafan // The CheckAssertionStatusDirectives boolean can be removed from here and 338350276Speter // globals.hpp after the AssertionStatusDirectives class has been integrated 338450276Speter // into merlin "for some time." Without it, the vm will fail with early 3385166124Srafan // merlin builds. 3386166124Srafan 3387166124Srafan if (CheckAssertionStatusDirectives && JDK_Version::is_gte_jdk14x_version()) { 338850276Speter const char* nm = "java/lang/AssertionStatusDirectives"; 3389166124Srafan const char* sig = "[Ljava/lang/String;"; 339050276Speter CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classes, sig); 3391166124Srafan CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classEnabled, "[Z"); 339250276Speter CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packages, sig); 339350276Speter CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packageEnabled, "[Z"); 3394166124Srafan CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, deflt, "Z"); 339550276Speter } 3396166124Srafan 3397166124Srafan if (!valid) vm_exit_during_initialization("Hard-coded field offset verification failed"); 3398166124Srafan} 339950276Speter 3400166124Srafan#endif // PRODUCT 3401166124Srafan 3402166124Srafanint InjectedField::compute_offset() { 3403166124Srafan Klass* klass_oop = klass(); 3404166124Srafan for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { 340550276Speter if (!may_be_java && !fs.access_flags().is_internal()) { 340650276Speter // Only look at injected fields 340750276Speter continue; 3408166124Srafan } 3409166124Srafan if (fs.name() == name() && fs.signature() == signature()) { 3410166124Srafan return fs.offset(); 341150276Speter } 3412166124Srafan } 3413166124Srafan ResourceMark rm; 3414174993Srafan 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)" : ""); 341562449Speter#ifndef PRODUCT 3416166124Srafan klass_oop->print(); 3417166124Srafan tty->print_cr("all fields:"); 3418166124Srafan for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { 3419166124Srafan tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); 342062449Speter } 342162449Speter#endif //PRODUCT 342266963Speter fatal("Invalid layout of preloaded class"); 342366963Speter return -1; 342466963Speter} 342566963Speter 3426166124Srafanvoid javaClasses_init() { 3427166124Srafan JavaClasses::compute_offsets(); 3428166124Srafan JavaClasses::check_offsets(); 3429166124Srafan FilteredFieldsMap::initialize(); // must be done after computing offsets. 3430166124Srafan} 3431166124Srafan