0N/A

0N/A# include "incls/_precompiled.incl"

0N/A# include "incls/_javaClasses.cpp.incl"

0N/A

0N/A#define COMPUTE_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \

0N/A{ \

0N/A fieldDescriptor fd; \

0N/A instanceKlass* ik = instanceKlass::cast(klass_oop); \

0N/A if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) { \

0N/A fatal("Invalid layout of " klass_name_as_C_str); \

0N/A } \

0N/A dest_offset = fd.offset(); \

0N/A}

0N/A

0N/A#define COMPUTE_OPTIONAL_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \

0N/A{ \

0N/A fieldDescriptor fd; \

0N/A instanceKlass* ik = instanceKlass::cast(klass_oop); \

0N/A if (ik->find_local_field(name_symbol, signature_symbol, &fd)) { \

0N/A dest_offset = fd.offset(); \

0N/A } \

0N/A}

0N/A

0N/AHandle java_lang_String::basic_create(int length, bool tenured, TRAPS) {

0N/A // Create the String object first, so there's a chance that the String

0N/A // and the char array it points to end up in the same cache line.

0N/A oop obj;

0N/A if (tenured) {

0N/A obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);

0N/A } else {

0N/A obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);

0N/A }

0N/A

0N/A // Create the char array. The String object must be handlized here

0N/A // because GC can happen as a result of the allocation attempt.

0N/A Handle h_obj(THREAD, obj);

0N/A typeArrayOop buffer;

0N/A if (tenured) {

0N/A buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);

0N/A } else {

0N/A buffer = oopFactory::new_charArray(length, CHECK_NH);

0N/A }

0N/A

0N/A // Point the String at the char array

0N/A obj = h_obj();

0N/A set_value(obj, buffer);

0N/A // No need to zero the offset, allocation zero'ed the entire String object

0N/A assert(offset(obj) == 0, "initial String offset should be zero");

0N/A set_count(obj, length);

0N/A

0N/A return h_obj;

0N/A}

0N/A

0N/AHandle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) {

0N/A Handle h_obj = basic_create(length, tenured, CHECK_NH);

0N/A typeArrayOop buffer = value(h_obj());

0N/A for (int index = 0; index < length; index++) {

0N/A buffer->char_at_put(index, unicode[index]);

0N/A }

0N/A return h_obj;

0N/A}

0N/A

0N/AHandle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {

0N/A return basic_create_from_unicode(unicode, length, false, CHECK_NH);

0N/A}

0N/A

0N/AHandle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) {

0N/A return basic_create_from_unicode(unicode, length, true, CHECK_NH);

0N/A}

0N/A

0N/Aoop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {

0N/A Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0);

0N/A return h_obj();

0N/A}

0N/A

0N/AHandle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {

0N/A if (utf8_str == NULL) {

0N/A return Handle();

0N/A }

0N/A int length = UTF8::unicode_length(utf8_str);

0N/A Handle h_obj = basic_create(length, false, CHECK_NH);

0N/A if (length > 0) {

0N/A UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);

0N/A }

0N/A return h_obj;

0N/A}

0N/A

0N/Aoop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {

0N/A Handle h_obj = create_from_str(utf8_str, CHECK_0);

0N/A return h_obj();

0N/A}

0N/A

0N/AHandle java_lang_String::create_from_symbol(symbolHandle symbol, TRAPS) {

0N/A int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());

0N/A Handle h_obj = basic_create(length, false, CHECK_NH);

0N/A if (length > 0) {

0N/A UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);

0N/A }

0N/A return h_obj;

0N/A}

0N/A

0N/AHandle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {

0N/A assert(str != NULL, "bad arguments");

0N/A

0N/A typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);

0N/A static to_java_string_fn_t _to_java_string_fn = NULL;

0N/A

0N/A if (_to_java_string_fn == NULL) {

0N/A void *lib_handle = os::native_java_library();

0N/A _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, hpi::dll_lookup(lib_handle, "NewStringPlatform"));

0N/A if (_to_java_string_fn == NULL) {

0N/A fatal("NewStringPlatform missing");

0N/A }

0N/A }

0N/A

0N/A jstring js = NULL;

0N/A { JavaThread* thread = (JavaThread*)THREAD;

0N/A assert(thread->is_Java_thread(), "must be java thread");

0N/A ThreadToNativeFromVM ttn(thread);

0N/A HandleMark hm(thread);

0N/A js = (_to_java_string_fn)(thread->jni_environment(), str);

0N/A }

0N/A return Handle(THREAD, JNIHandles::resolve(js));

0N/A}

0N/A

0N/AHandle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) {

0N/A oop obj = java_string();

0N/A // Typical usage is to convert all '/' to '.' in string.

0N/A typeArrayOop value = java_lang_String::value(obj);

0N/A int offset = java_lang_String::offset(obj);

0N/A int length = java_lang_String::length(obj);

0N/A

0N/A // First check if any from_char exist

0N/A int index; // Declared outside, used later

0N/A for (index = 0; index < length; index++) {

0N/A if (value->char_at(index + offset) == from_char) {

0N/A break;

0N/A }

0N/A }

0N/A if (index == length) {

0N/A // No from_char, so do not copy.

0N/A return java_string;

0N/A }

0N/A

0N/A // Create new UNICODE buffer. Must handlize value because GC

0N/A // may happen during String and char array creation.

0N/A typeArrayHandle h_value(THREAD, value);

0N/A Handle string = basic_create(length, false, CHECK_NH);

0N/A

0N/A typeArrayOop from_buffer = h_value();

0N/A typeArrayOop to_buffer = java_lang_String::value(string());

0N/A

0N/A // Copy contents

0N/A for (index = 0; index < length; index++) {

0N/A jchar c = from_buffer->char_at(index + offset);

0N/A if (c == from_char) {

0N/A c = to_char;

0N/A }

0N/A to_buffer->char_at_put(index, c);

0N/A }

0N/A return string;

0N/A}

0N/A

0N/Ajchar* java_lang_String::as_unicode_string(oop java_string, int& length) {

0N/A typeArrayOop value = java_lang_String::value(java_string);

0N/A int offset = java_lang_String::offset(java_string);

0N/A length = java_lang_String::length(java_string);

0N/A

0N/A jchar* result = NEW_RESOURCE_ARRAY(jchar, length);

0N/A for (int index = 0; index < length; index++) {

0N/A result[index] = value->char_at(index + offset);

0N/A }

0N/A return result;

0N/A}

0N/A

0N/AsymbolHandle java_lang_String::as_symbol(Handle java_string, TRAPS) {

0N/A oop obj = java_string();

0N/A typeArrayOop value = java_lang_String::value(obj);

0N/A int offset = java_lang_String::offset(obj);

0N/A int length = java_lang_String::length(obj);

0N/A

0N/A ResourceMark rm(THREAD);

0N/A symbolHandle result;

0N/A

0N/A if (length > 0) {

0N/A int utf8_length = UNICODE::utf8_length(value->char_at_addr(offset), length);

0N/A char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);

0N/A UNICODE::convert_to_utf8(value->char_at_addr(offset), length, chars);

0N/A // Allocate the symbol

0N/A result = oopFactory::new_symbol_handle(chars, utf8_length, CHECK_(symbolHandle()));

0N/A } else {

0N/A result = oopFactory::new_symbol_handle("", 0, CHECK_(symbolHandle()));

0N/A }

0N/A return result;

0N/A}

0N/A

0N/Aint java_lang_String::utf8_length(oop java_string) {

0N/A typeArrayOop value = java_lang_String::value(java_string);

0N/A int offset = java_lang_String::offset(java_string);

0N/A int length = java_lang_String::length(java_string);

0N/A jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);

0N/A return UNICODE::utf8_length(position, length);

0N/A}

0N/A

0N/Achar* java_lang_String::as_utf8_string(oop java_string) {

0N/A typeArrayOop value = java_lang_String::value(java_string);

0N/A int offset = java_lang_String::offset(java_string);

0N/A int length = java_lang_String::length(java_string);

0N/A jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);

0N/A return UNICODE::as_utf8(position, length);

0N/A}

0N/A

0N/Achar* java_lang_String::as_utf8_string(oop java_string, int start, int len) {

0N/A typeArrayOop value = java_lang_String::value(java_string);

0N/A int offset = java_lang_String::offset(java_string);

0N/A int length = java_lang_String::length(java_string);

0N/A assert(start + len <= length, "just checking");

0N/A jchar* position = value->char_at_addr(offset + start);

0N/A return UNICODE::as_utf8(position, len);

0N/A}

0N/A

0N/Abool java_lang_String::equals(oop java_string, jchar* chars, int len) {

0N/A assert(SharedSkipVerify ||

0N/A java_string->klass() == SystemDictionary::string_klass(),

0N/A "must be java_string");

0N/A typeArrayOop value = java_lang_String::value(java_string);

0N/A int offset = java_lang_String::offset(java_string);

0N/A int length = java_lang_String::length(java_string);

0N/A if (length != len) {

0N/A return false;

0N/A }

0N/A for (int i = 0; i < len; i++) {

0N/A if (value->char_at(i + offset) != chars[i]) {

0N/A return false;

0N/A }

0N/A }

0N/A return true;

0N/A}

0N/A

0N/Avoid java_lang_String::print(Handle java_string, outputStream* st) {

0N/A oop obj = java_string();

0N/A assert(obj->klass() == SystemDictionary::string_klass(), "must be java_string");

0N/A typeArrayOop value = java_lang_String::value(obj);

0N/A int offset = java_lang_String::offset(obj);

0N/A int length = java_lang_String::length(obj);

0N/A

0N/A int end = MIN2(length, 100);

0N/A if (value == NULL) {

0N/A // This can happen if, e.g., printing a String

0N/A // object before its initializer has been called

0N/A st->print_cr("NULL");

0N/A } else {

0N/A st->print("\"");

0N/A for (int index = 0; index < length; index++) {

0N/A st->print("%c", value->char_at(index + offset));

0N/A }

0N/A st->print("\"");

0N/A }

0N/A}

0N/A

0N/A

0N/Aoop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {

0N/A assert(k->java_mirror() == NULL, "should only assign mirror once");

0N/A // Use this moment of initialization to cache modifier_flags also,

0N/A // to support Class.getModifiers(). Instance classes recalculate

0N/A // the cached flags after the class file is parsed, but before the

0N/A // class is put into the system dictionary.

0N/A int computed_modifiers = k->compute_modifier_flags(CHECK_0);

0N/A k->set_modifier_flags(computed_modifiers);

0N/A if (SystemDictionary::class_klass_loaded()) {

0N/A // Allocate mirror (java.lang.Class instance)

0N/A Handle mirror = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);

0N/A // Setup indirections

0N/A mirror->obj_field_put(klass_offset, k());

0N/A k->set_java_mirror(mirror());

0N/A // It might also have a component mirror. This mirror must already exist.

0N/A if (k->oop_is_javaArray()) {

0N/A Handle comp_mirror;

0N/A if (k->oop_is_typeArray()) {

0N/A BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();

0N/A comp_mirror = Universe::java_mirror(type);

0N/A assert(comp_mirror.not_null(), "must have primitive mirror");

0N/A } else if (k->oop_is_objArray()) {

0N/A klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();

0N/A if (element_klass != NULL

0N/A && (Klass::cast(element_klass)->oop_is_instance() ||

0N/A Klass::cast(element_klass)->oop_is_javaArray())) {

0N/A comp_mirror = Klass::cast(element_klass)->java_mirror();

0N/A assert(comp_mirror.not_null(), "must have element mirror");

0N/A }

0N/A // else some object array internal to the VM, like systemObjArrayKlassObj

0N/A }

0N/A if (comp_mirror.not_null()) {

0N/A // Two-way link between the array klass and its component mirror:

0N/A arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());

0N/A set_array_klass(comp_mirror(), k->as_klassOop());

0N/A }

0N/A }

0N/A return mirror();

0N/A } else {

0N/A return NULL;

0N/A }

0N/A}

0N/A

0N/A

0N/Aoop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {

0N/A // This should be improved by adding a field at the Java level or by

0N/A // introducing a new VM klass (see comment in ClassFileParser)

0N/A oop java_class = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);

0N/A if (type != T_VOID) {

0N/A klassOop aklass = Universe::typeArrayKlassObj(type);

0N/A assert(aklass != NULL, "correct bootstrap");

0N/A set_array_klass(java_class, aklass);

0N/A }

0N/A return java_class;

0N/A}

0N/A

0N/A

0N/AklassOop java_lang_Class::as_klassOop(oop java_class) {

0N/A //%note memory_2

0N/A klassOop k = klassOop(java_class->obj_field(klass_offset));

0N/A assert(k == NULL || k->is_klass(), "type check");

0N/A return k;

0N/A}

0N/A

0N/A

0N/AklassOop java_lang_Class::array_klass(oop java_class) {

0N/A klassOop k = klassOop(java_class->obj_field(array_klass_offset));

0N/A assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass");

0N/A return k;

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Class::set_array_klass(oop java_class, klassOop klass) {

0N/A assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass");

0N/A java_class->obj_field_put(array_klass_offset, klass);

0N/A}

0N/A

0N/A

0N/AmethodOop java_lang_Class::resolved_constructor(oop java_class) {

0N/A oop constructor = java_class->obj_field(resolved_constructor_offset);

0N/A assert(constructor == NULL || constructor->is_method(), "should be method");

0N/A return methodOop(constructor);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) {

0N/A assert(constructor->is_method(), "should be method");

0N/A java_class->obj_field_put(resolved_constructor_offset, constructor);

0N/A}

0N/A

0N/A

0N/Abool java_lang_Class::is_primitive(oop java_class) {

0N/A klassOop k = klassOop(java_class->obj_field(klass_offset));

0N/A return k == NULL;

0N/A}

0N/A

0N/A

0N/ABasicType java_lang_Class::primitive_type(oop java_class) {

0N/A assert(java_lang_Class::is_primitive(java_class), "just checking");

0N/A klassOop ak = klassOop(java_class->obj_field(array_klass_offset));

0N/A BasicType type = T_VOID;

0N/A if (ak != NULL) {

0N/A // Note: create_basic_type_mirror above initializes ak to a non-null value.

0N/A type = arrayKlass::cast(ak)->element_type();

0N/A } else {

0N/A assert(java_class == Universe::void_mirror(), "only valid non-array primitive");

0N/A }

0N/A assert(Universe::java_mirror(type) == java_class, "must be consistent");

0N/A return type;

0N/A}

0N/A

0N/A

0N/Aoop java_lang_Class::primitive_mirror(BasicType t) {

0N/A oop mirror = Universe::java_mirror(t);

0N/A assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");

0N/A assert(java_lang_Class::is_primitive(mirror), "must be primitive");

0N/A return mirror;

0N/A}

0N/A

0N/Abool java_lang_Class::offsets_computed = false;

0N/Aint java_lang_Class::classRedefinedCount_offset = -1;

0N/A

0N/Avoid java_lang_Class::compute_offsets() {

0N/A assert(!offsets_computed, "offsets should be initialized only once");

0N/A offsets_computed = true;

0N/A

0N/A klassOop k = SystemDictionary::class_klass();

0N/A // The classRedefinedCount field is only present starting in 1.5,

0N/A // so don't go fatal.

0N/A COMPUTE_OPTIONAL_OFFSET("java.lang.Class", classRedefinedCount_offset,

0N/A k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());

0N/A}

0N/A

0N/Aint java_lang_Class::classRedefinedCount(oop the_class_mirror) {

0N/A if (!JDK_Version::is_gte_jdk15x_version()

0N/A || classRedefinedCount_offset == -1) {

0N/A // The classRedefinedCount field is only present starting in 1.5.

0N/A // If we don't have an offset for it then just return -1 as a marker.

0N/A return -1;

0N/A }

0N/A

0N/A return the_class_mirror->int_field(classRedefinedCount_offset);

0N/A}

0N/A

0N/Avoid java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {

0N/A if (!JDK_Version::is_gte_jdk15x_version()

0N/A || classRedefinedCount_offset == -1) {

0N/A // The classRedefinedCount field is only present starting in 1.5.

0N/A // If we don't have an offset for it then nothing to set.

0N/A return;

0N/A }

0N/A

0N/A the_class_mirror->int_field_put(classRedefinedCount_offset, value);

0N/A}

0N/A

0N/A

0N/A

0N/Aint java_lang_Thread::_name_offset = 0;

0N/Aint java_lang_Thread::_group_offset = 0;

0N/Aint java_lang_Thread::_contextClassLoader_offset = 0;

0N/Aint java_lang_Thread::_inheritedAccessControlContext_offset = 0;

0N/Aint java_lang_Thread::_priority_offset = 0;

0N/Aint java_lang_Thread::_eetop_offset = 0;

0N/Aint java_lang_Thread::_daemon_offset = 0;

0N/Aint java_lang_Thread::_stillborn_offset = 0;

0N/Aint java_lang_Thread::_stackSize_offset = 0;

0N/Aint java_lang_Thread::_tid_offset = 0;

0N/Aint java_lang_Thread::_thread_status_offset = 0;

0N/Aint java_lang_Thread::_park_blocker_offset = 0;

0N/Aint java_lang_Thread::_park_event_offset = 0 ;

0N/A

0N/A

0N/Avoid java_lang_Thread::compute_offsets() {

0N/A assert(_group_offset == 0, "offsets should be initialized only once");

0N/A

0N/A klassOop k = SystemDictionary::thread_klass();

0N/A COMPUTE_OFFSET("java.lang.Thread", _name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature());

0N/A COMPUTE_OFFSET("java.lang.Thread", _stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());

0N/A // The stackSize field is only present starting in 1.4, so don't go fatal.

0N/A COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());

0N/A // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.

0N/A COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());

0N/A COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());

0N/A // The parkBlocker field is only present starting in 1.6, so don't go fatal.

0N/A COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());

0N/A COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_event_offset, k, vmSymbols::park_event_name(),

0N/A vmSymbols::long_signature());

0N/A}

0N/A

0N/A

0N/AJavaThread* java_lang_Thread::thread(oop java_thread) {

0N/A return (JavaThread*) java_thread->obj_field(_eetop_offset);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {

0N/A // We are storing a JavaThread* (malloc'ed data) into a long field in the thread

0N/A // object. The store has to be 64-bit wide so we use a pointer store, but we

0N/A // cannot call oopDesc::obj_field_put since it includes a write barrier!

0N/A oop* addr = java_thread->obj_field_addr(_eetop_offset);

0N/A *addr = (oop) thread;

0N/A}

0N/A

0N/A

0N/AtypeArrayOop java_lang_Thread::name(oop java_thread) {

0N/A oop name = java_thread->obj_field(_name_offset);

0N/A assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");

0N/A return typeArrayOop(name);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Thread::set_name(oop java_thread, typeArrayOop name) {

0N/A assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL");

0N/A java_thread->obj_field_put(_name_offset, name);

0N/A}

0N/A

0N/A

0N/AThreadPriority java_lang_Thread::priority(oop java_thread) {

0N/A return (ThreadPriority)java_thread->int_field(_priority_offset);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Thread::set_priority(oop java_thread, ThreadPriority priority) {

0N/A java_thread->int_field_put(_priority_offset, priority);

0N/A}

0N/A

0N/A

0N/Aoop java_lang_Thread::threadGroup(oop java_thread) {

0N/A return java_thread->obj_field(_group_offset);

0N/A}

0N/A

0N/A

0N/Abool java_lang_Thread::is_stillborn(oop java_thread) {

0N/A return java_thread->bool_field(_stillborn_offset) != 0;

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Thread::set_stillborn(oop java_thread) {

0N/A java_thread->bool_field_put(_stillborn_offset, true);

0N/A}

0N/A

0N/A

0N/Abool java_lang_Thread::is_alive(oop java_thread) {

0N/A JavaThread* thr = java_lang_Thread::thread(java_thread);

0N/A return (thr != NULL);

0N/A}

0N/A

0N/A

0N/Abool java_lang_Thread::is_daemon(oop java_thread) {

0N/A return java_thread->bool_field(_daemon_offset) != 0;

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Thread::set_daemon(oop java_thread) {

0N/A java_thread->bool_field_put(_daemon_offset, true);

0N/A}

0N/A

0N/Aoop java_lang_Thread::context_class_loader(oop java_thread) {

0N/A return java_thread->obj_field(_contextClassLoader_offset);

0N/A}

0N/A

0N/Aoop java_lang_Thread::inherited_access_control_context(oop java_thread) {

0N/A return java_thread->obj_field(_inheritedAccessControlContext_offset);

0N/A}

0N/A

0N/A

0N/Ajlong java_lang_Thread::stackSize(oop java_thread) {

0N/A // The stackSize field is only present starting in 1.4

0N/A if (_stackSize_offset > 0) {

0N/A assert(JDK_Version::is_gte_jdk14x_version(), "sanity check");

0N/A return java_thread->long_field(_stackSize_offset);

0N/A } else {

0N/A return 0;

0N/A }

0N/A}

0N/A

0N/Avoid java_lang_Thread::set_thread_status(oop java_thread,

0N/A java_lang_Thread::ThreadStatus status) {

0N/A assert(JavaThread::current()->thread_state() == _thread_in_vm, "Java Thread is not running in vm");

0N/A // The threadStatus is only present starting in 1.5

0N/A if (_thread_status_offset > 0) {

0N/A java_thread->int_field_put(_thread_status_offset, status);

0N/A }

0N/A}

0N/A

0N/Ajava_lang_Thread::ThreadStatus java_lang_Thread::get_thread_status(oop java_thread) {

0N/A assert(Thread::current()->is_VM_thread() ||

0N/A JavaThread::current()->thread_state() == _thread_in_vm,

0N/A "Java Thread is not running in vm");

0N/A // The threadStatus is only present starting in 1.5

0N/A if (_thread_status_offset > 0) {

0N/A return (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset);

0N/A } else {

0N/A // All we can easily figure out is if it is alive, but that is

0N/A // enough info for a valid unknown status.

0N/A // These aren't restricted to valid set ThreadStatus values, so

0N/A // use JVMTI values and cast.

0N/A JavaThread* thr = java_lang_Thread::thread(java_thread);

0N/A if (thr == NULL) {

0N/A // the thread hasn't run yet or is in the process of exiting

0N/A return NEW;

0N/A }

0N/A return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE;

0N/A }

0N/A}

0N/A

0N/A

0N/Ajlong java_lang_Thread::thread_id(oop java_thread) {

0N/A // The thread ID field is only present starting in 1.5

0N/A if (_tid_offset > 0) {

0N/A return java_thread->long_field(_tid_offset);

0N/A } else {

0N/A return 0;

0N/A }

0N/A}

0N/A

0N/Aoop java_lang_Thread::park_blocker(oop java_thread) {

0N/A assert(JDK_Version::supports_thread_park_blocker() && _park_blocker_offset != 0,

0N/A "Must support parkBlocker field");

0N/A

0N/A if (_park_blocker_offset > 0) {

0N/A return java_thread->obj_field(_park_blocker_offset);

0N/A }

0N/A

0N/A return NULL;

0N/A}

0N/A

0N/Ajlong java_lang_Thread::park_event(oop java_thread) {

0N/A if (_park_event_offset > 0) {

0N/A return java_thread->long_field(_park_event_offset);

0N/A }

0N/A return 0;

0N/A}

0N/A

0N/Abool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) {

0N/A if (_park_event_offset > 0) {

0N/A java_thread->long_field_put(_park_event_offset, ptr);

0N/A return true;

0N/A }

0N/A return false;

0N/A}

0N/A

0N/A

0N/Aconst char* java_lang_Thread::thread_status_name(oop java_thread) {

0N/A assert(JDK_Version::is_gte_jdk15x_version() && _thread_status_offset != 0, "Must have thread status");

0N/A ThreadStatus status = (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset);

0N/A switch (status) {

0N/A case NEW : return "NEW";

0N/A case RUNNABLE : return "RUNNABLE";

0N/A case SLEEPING : return "TIMED_WAITING (sleeping)";

0N/A case IN_OBJECT_WAIT : return "WAITING (on object monitor)";

0N/A case IN_OBJECT_WAIT_TIMED : return "TIMED_WAITING (on object monitor)";

0N/A case PARKED : return "WAITING (parking)";

0N/A case PARKED_TIMED : return "TIMED_WAITING (parking)";

0N/A case BLOCKED_ON_MONITOR_ENTER : return "BLOCKED (on object monitor)";

0N/A case TERMINATED : return "TERMINATED";

0N/A default : return "UNKNOWN";

0N/A };

0N/A}

0N/Aint java_lang_ThreadGroup::_parent_offset = 0;

0N/Aint java_lang_ThreadGroup::_name_offset = 0;

0N/Aint java_lang_ThreadGroup::_threads_offset = 0;

0N/Aint java_lang_ThreadGroup::_groups_offset = 0;

0N/Aint java_lang_ThreadGroup::_maxPriority_offset = 0;

0N/Aint java_lang_ThreadGroup::_destroyed_offset = 0;

0N/Aint java_lang_ThreadGroup::_daemon_offset = 0;

0N/Aint java_lang_ThreadGroup::_vmAllowSuspension_offset = 0;

0N/Aint java_lang_ThreadGroup::_nthreads_offset = 0;

0N/Aint java_lang_ThreadGroup::_ngroups_offset = 0;

0N/A

0N/Aoop java_lang_ThreadGroup::parent(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return java_thread_group->obj_field(_parent_offset);

0N/A}

0N/A

0N/A

0N/AtypeArrayOop java_lang_ThreadGroup::name(oop java_thread_group) {

0N/A oop name = java_thread_group->obj_field(_name_offset);

0N/A // ThreadGroup.name can be null

0N/A return name == NULL ? (typeArrayOop)NULL : java_lang_String::value(name);

0N/A}

0N/A

0N/Aint java_lang_ThreadGroup::nthreads(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return java_thread_group->int_field(_nthreads_offset);

0N/A}

0N/A

0N/AobjArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) {

0N/A oop threads = java_thread_group->obj_field(_threads_offset);

0N/A assert(threads != NULL, "threadgroups should have threads");

0N/A assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code

0N/A return objArrayOop(threads);

0N/A}

0N/A

0N/Aint java_lang_ThreadGroup::ngroups(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return java_thread_group->int_field(_ngroups_offset);

0N/A}

0N/A

0N/AobjArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) {

0N/A oop groups = java_thread_group->obj_field(_groups_offset);

0N/A assert(groups == NULL || groups->is_objArray(), "just checking"); // Todo: Add better type checking code

0N/A return objArrayOop(groups);

0N/A}

0N/A

0N/AThreadPriority java_lang_ThreadGroup::maxPriority(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return (ThreadPriority) java_thread_group->int_field(_maxPriority_offset);

0N/A}

0N/A

0N/Abool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return java_thread_group->bool_field(_destroyed_offset) != 0;

0N/A}

0N/A

0N/Abool java_lang_ThreadGroup::is_daemon(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return java_thread_group->bool_field(_daemon_offset) != 0;

0N/A}

0N/A

0N/Abool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {

0N/A assert(java_thread_group->is_oop(), "thread group must be oop");

0N/A return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;

0N/A}

0N/A

0N/Avoid java_lang_ThreadGroup::compute_offsets() {

0N/A assert(_parent_offset == 0, "offsets should be initialized only once");

0N/A

0N/A klassOop k = SystemDictionary::threadGroup_klass();

0N/A

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());

0N/A COMPUTE_OFFSET("java.lang.ThreadGroup", _ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());

0N/A}

0N/A

0N/Aoop java_lang_Throwable::backtrace(oop throwable) {

0N/A return throwable->obj_field_acquire(backtrace_offset);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::set_backtrace(oop throwable, oop value) {

0N/A throwable->release_obj_field_put(backtrace_offset, value);

0N/A}

0N/A

0N/A

0N/Aoop java_lang_Throwable::message(oop throwable) {

0N/A return throwable->obj_field(detailMessage_offset);

0N/A}

0N/A

0N/A

0N/Aoop java_lang_Throwable::message(Handle throwable) {

0N/A return throwable->obj_field(detailMessage_offset);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::set_message(oop throwable, oop value) {

0N/A throwable->obj_field_put(detailMessage_offset, value);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::clear_stacktrace(oop throwable) {

0N/A assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");

0N/A throwable->obj_field_put(stackTrace_offset, NULL);

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::print(oop throwable, outputStream* st) {

0N/A ResourceMark rm;

0N/A klassOop k = throwable->klass();

0N/A assert(k != NULL, "just checking");

0N/A st->print("%s", instanceKlass::cast(k)->external_name());

0N/A oop msg = message(throwable);

0N/A if (msg != NULL) {

0N/A st->print(": %s", java_lang_String::as_utf8_string(msg));

0N/A }

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::print(Handle throwable, outputStream* st) {

0N/A ResourceMark rm;

0N/A klassOop k = throwable->klass();

0N/A assert(k != NULL, "just checking");

0N/A st->print("%s", instanceKlass::cast(k)->external_name());

0N/A oop msg = message(throwable);

0N/A if (msg != NULL) {

0N/A st->print(": %s", java_lang_String::as_utf8_string(msg));

0N/A }

0N/A}

0N/A

0N/Achar* java_lang_Throwable::print_stack_element_to_buffer(methodOop method, int bci) {

0N/A // Get strings and string lengths

0N/A instanceKlass* klass = instanceKlass::cast(method->method_holder());

0N/A const char* klass_name = klass->external_name();

0N/A int buf_len = (int)strlen(klass_name);

0N/A char* source_file_name;

0N/A if (klass->source_file_name() == NULL) {

0N/A source_file_name = NULL;

0N/A } else {

0N/A source_file_name = klass->source_file_name()->as_C_string();

0N/A buf_len += (int)strlen(source_file_name);

0N/A }

0N/A char* method_name = method->name()->as_C_string();

0N/A buf_len += (int)strlen(method_name);

0N/A

0N/A // Allocate temporary buffer with extra space for formatting and line number

0N/A char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);

0N/A

0N/A // Print stack trace line in buffer

0N/A sprintf(buf, "\tat %s.%s", klass_name, method_name);

0N/A if (method->is_native()) {

0N/A strcat(buf, "(Native Method)");

0N/A } else {

0N/A int line_number = method->line_number_from_bci(bci);

0N/A if (source_file_name != NULL && (line_number != -1)) {

0N/A // Sourcename and linenumber

0N/A sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);

0N/A } else if (source_file_name != NULL) {

0N/A // Just sourcename

0N/A sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);

0N/A } else {

0N/A // Neither soucename and linenumber

0N/A sprintf(buf + (int)strlen(buf), "(Unknown Source)");

0N/A }

0N/A nmethod* nm = method->code();

0N/A if (WizardMode && nm != NULL) {

0N/A sprintf(buf + (int)strlen(buf), "(nmethod %#x)", nm);

0N/A }

0N/A }

0N/A

0N/A return buf;

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::print_stack_element(Handle stream, methodOop method, int bci) {

0N/A ResourceMark rm;

0N/A char* buf = print_stack_element_to_buffer(method, bci);

0N/A print_to_stream(stream, buf);

0N/A}

0N/A

0N/Avoid java_lang_Throwable::print_stack_element(outputStream *st, methodOop method, int bci) {

0N/A ResourceMark rm;

0N/A char* buf = print_stack_element_to_buffer(method, bci);

0N/A st->print_cr("%s", buf);

0N/A}

0N/A

0N/Avoid java_lang_Throwable::print_to_stream(Handle stream, const char* str) {

0N/A if (stream.is_null()) {

0N/A tty->print_cr("%s", str);

0N/A } else {

0N/A EXCEPTION_MARK;

0N/A JavaValue result(T_VOID);

0N/A Handle arg (THREAD, oopFactory::new_charArray(str, THREAD));

0N/A if (!HAS_PENDING_EXCEPTION) {

0N/A JavaCalls::call_virtual(&result,

0N/A stream,

0N/A KlassHandle(THREAD, stream->klass()),

0N/A vmSymbolHandles::println_name(),

0N/A vmSymbolHandles::char_array_void_signature(),

0N/A arg,

0N/A THREAD);

0N/A }

0N/A // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.

0N/A if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;

0N/A }

0N/A

0N/A}

0N/A

0N/A

0N/Aconst char* java_lang_Throwable::no_stack_trace_message() {

0N/A return "\t<<no stack trace available>>";

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) {

0N/A Thread *THREAD = Thread::current();

0N/A Handle h_throwable(THREAD, throwable);

0N/A while (h_throwable.not_null()) {

0N/A objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));

0N/A if (result.is_null()) {

0N/A st->print_cr(no_stack_trace_message());

0N/A return;

0N/A }

0N/A

0N/A while (result.not_null()) {

0N/A objArrayHandle methods (THREAD,

0N/A objArrayOop(result->obj_at(trace_methods_offset)));

0N/A typeArrayHandle bcis (THREAD,

0N/A typeArrayOop(result->obj_at(trace_bcis_offset)));

0N/A

0N/A if (methods.is_null() || bcis.is_null()) {

0N/A st->print_cr(no_stack_trace_message());

0N/A return;

0N/A }

0N/A

0N/A int length = methods()->length();

0N/A for (int index = 0; index < length; index++) {

0N/A methodOop method = methodOop(methods()->obj_at(index));

0N/A if (method == NULL) goto handle_cause;

0N/A int bci = bcis->ushort_at(index);

0N/A print_stack_element(st, method, bci);

0N/A }

0N/A result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));

0N/A }

0N/A handle_cause:

0N/A {

0N/A EXCEPTION_MARK;

0N/A JavaValue result(T_OBJECT);

0N/A JavaCalls::call_virtual(&result,

0N/A h_throwable,

0N/A KlassHandle(THREAD, h_throwable->klass()),

0N/A vmSymbolHandles::getCause_name(),

0N/A vmSymbolHandles::void_throwable_signature(),

0N/A THREAD);

0N/A // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.

0N/A if (HAS_PENDING_EXCEPTION) {

0N/A CLEAR_PENDING_EXCEPTION;

0N/A h_throwable = Handle();

0N/A } else {

0N/A h_throwable = Handle(THREAD, (oop) result.get_jobject());

0N/A if (h_throwable.not_null()) {

0N/A st->print("Caused by: ");

0N/A print(h_throwable, st);

0N/A st->cr();

0N/A }

0N/A }

0N/A }

0N/A }

0N/A}

0N/A

0N/A

0N/Avoid java_lang_Throwable::print_stack_trace(oop throwable, oop print_stream) {

0N/A // Note: this is no longer used in Merlin, but we support it for compatibility.

0N/A Thread *thread = Thread::current();

0N/A Handle stream(thread, print_stream);

0N/A objArrayHandle result (thread, objArrayOop(backtrace(throwable)));

0N/A if (result.is_null()) {

0N/A print_to_stream(stream, no_stack_trace_message());

0N/A return;

0N/A }

0N/A

0N/A while (result.not_null()) {

0N/A objArrayHandle methods (thread,

0N/A objArrayOop(result->obj_at(trace_methods_offset)));

0N/A typeArrayHandle bcis (thread,

0N/A typeArrayOop(result->obj_at(trace_bcis_offset)));

0N/A

0N/A if (methods.is_null() || bcis.is_null()) {

0N/A print_to_stream(stream, no_stack_trace_message());

0N/A return;

0N/A }

0N/A

0N/A int length = methods()->length();

0N/A for (int index = 0; index < length; index++) {

0N/A methodOop method = methodOop(methods()->obj_at(index));

0N/A if (method == NULL) return;

0N/A int bci = bcis->ushort_at(index);

0N/A print_stack_element(stream, method, bci);

0N/A }

0N/A result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset)));

0N/A }

0N/A}

0N/A

0N/Aclass BacktraceBuilder: public StackObj {

0N/A private:

0N/A Handle _backtrace;

0N/A objArrayOop _head;

0N/A objArrayOop _methods;

0N/A typeArrayOop _bcis;

0N/A int _index;

0N/A bool _dirty;

0N/A bool _done;

0N/A No_Safepoint_Verifier _nsv;

0N/A

0N/A public:

0N/A

0N/A enum {

0N/A trace_methods_offset = java_lang_Throwable::trace_methods_offset,

0N/A trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,

0N/A trace_next_offset = java_lang_Throwable::trace_next_offset,

0N/A trace_size = java_lang_Throwable::trace_size,

0N/A trace_chunk_size = java_lang_Throwable::trace_chunk_size

0N/A };

0N/A

0N/A // constructor for new backtrace

0N/A BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL) {

0N/A expand(CHECK);

0N/A _backtrace = _head;

0N/A _index = 0;

0N/A _dirty = false;

0N/A _done = false;

0N/A }

0N/A

0N/A void flush() {

0N/A if (_dirty && _methods != NULL) {

0N/A BarrierSet* bs = Universe::heap()->barrier_set();

0N/A assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");

0N/A bs->write_ref_array(MemRegion((HeapWord*)_methods->obj_at_addr(0),

0N/A _methods->length() * HeapWordsPerOop));

0N/A _dirty = false;

0N/A }

0N/A }

0N/A

0N/A void expand(TRAPS) {

0N/A flush();

0N/A

0N/A objArrayHandle old_head(THREAD, _head);

0N/A Pause_No_Safepoint_Verifier pnsv(&_nsv);

0N/A

0N/A objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);

0N/A objArrayHandle new_head(THREAD, head);

0N/A

0N/A objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK);

0N/A objArrayHandle new_methods(THREAD, methods);

0N/A

0N/A typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK);

0N/A typeArrayHandle new_bcis(THREAD, bcis);

0N/A

0N/A if (!old_head.is_null()) {

0N/A old_head->obj_at_put(trace_next_offset, new_head());

0N/A }

0N/A new_head->obj_at_put(trace_methods_offset, new_methods());

0N/A new_head->obj_at_put(trace_bcis_offset, new_bcis());

0N/A

0N/A _head = new_head();

0N/A _methods = new_methods();

0N/A _bcis = new_bcis();

0N/A _index = 0;

0N/A }

0N/A

0N/A oop backtrace() {

0N/A flush();

0N/A return _backtrace();

0N/A }

0N/A

0N/A inline void push(methodOop method, short bci, TRAPS) {

0N/A if (_index >= trace_chunk_size) {

0N/A methodHandle mhandle(THREAD, method);

0N/A expand(CHECK);

0N/A method = mhandle();

0N/A }

0N/A

0N/A // _methods->obj_at_put(_index, method);

0N/A *_methods->obj_at_addr(_index) = method;

0N/A _bcis->ushort_at_put(_index, bci);

0N/A _index++;

0N/A _dirty = true;

0N/A }

0N/A

0N/A methodOop current_method() {

0N/A assert(_index >= 0 && _index < trace_chunk_size, "out of range");

0N/A return methodOop(_methods->obj_at(_index));

0N/A }

0N/A

0N/A jushort current_bci() {

0N/A assert(_index >= 0 && _index < trace_chunk_size, "out of range");

0N/A return _bcis->ushort_at(_index);

0N/A }

0N/A};

0N/A

0N/A

0N/Avoid java_lang_Throwable::fill_in_stack_trace(Handle throwable, TRAPS) {

0N/A if (!StackTraceInThrowable) return;

0N/A ResourceMark rm(THREAD);

0N/A

0N/A // Start out by clearing the backtrace for this object, in case the VM

0N/A // runs out of memory while allocating the stack trace

0N/A set_backtrace(throwable(), NULL);

0N/A if (JDK_Version::is_gte_jdk14x_version()) {

0N/A // New since 1.4, clear lazily constructed Java level stacktrace if

0N/A // refilling occurs

0N/A clear_stacktrace(throwable());

0N/A }

0N/A

0N/A int max_depth = MaxJavaStackTraceDepth;

0N/A JavaThread* thread = (JavaThread*)THREAD;

0N/A BacktraceBuilder bt(CHECK);

0N/A

0N/A // Instead of using vframe directly, this version of fill_in_stack_trace

0N/A // basically handles everything by hand. This significantly improved the

0N/A // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows.

0N/A // See bug 6333838 for more details.

0N/A // The "ASSERT" here is to verify this method generates the exactly same stack

0N/A // trace as utilizing vframe.

0N/A#ifdef ASSERT

0N/A vframeStream st(thread);

0N/A methodHandle st_method(THREAD, st.method());

0N/A#endif

0N/A int total_count = 0;

0N/A RegisterMap map(thread, false);

0N/A int decode_offset = 0;

0N/A nmethod* nm = NULL;

0N/A bool skip_fillInStackTrace_check = false;

0N/A bool skip_throwableInit_check = false;

0N/A

0N/A for (frame fr = thread->last_frame(); max_depth != total_count;) {

0N/A methodOop method = NULL;

0N/A int bci = 0;

0N/A

0N/A // Compiled java method case.

0N/A if (decode_offset != 0) {

0N/A DebugInfoReadStream stream(nm, decode_offset);

0N/A decode_offset = stream.read_int();

0N/A method = (methodOop)nm->oop_at(stream.read_int());

0N/A bci = stream.read_bci();

0N/A } else {

0N/A if (fr.is_first_frame()) break;

0N/A address pc = fr.pc();

0N/A if (fr.is_interpreted_frame()) {

0N/A intptr_t bcx = fr.interpreter_frame_bcx();

0N/A method = fr.interpreter_frame_method();

0N/A bci = fr.is_bci(bcx) ? bcx : method->bci_from((address)bcx);

0N/A fr = fr.sender(&map);

0N/A } else {

0N/A CodeBlob* cb = fr.cb();

0N/A // HMMM QQQ might be nice to have frame return nm as NULL if cb is non-NULL

0N/A // but non nmethod

0N/A fr = fr.sender(&map);

0N/A if (cb == NULL || !cb->is_nmethod()) {

0N/A continue;

0N/A }

0N/A nm = (nmethod*)cb;

0N/A if (nm->method()->is_native()) {

0N/A method = nm->method();

0N/A bci = 0;

0N/A } else {

0N/A PcDesc* pd = nm->pc_desc_at(pc);

0N/A decode_offset = pd->scope_decode_offset();

0N/A // if decode_offset is not equal to 0, it will execute the

0N/A // "compiled java method case" at the beginning of the loop.

0N/A continue;

0N/A }

0N/A }

0N/A }

0N/A#ifdef ASSERT

0N/A assert(st_method() == method && st.bci() == bci,

0N/A "Wrong stack trace");

0N/A st.next();

0N/A // vframeStream::method isn't GC-safe so store off a copy

0N/A // of the methodOop in case we GC.

0N/A if (!st.at_end()) {

0N/A st_method = st.method();

0N/A }

0N/A#endif

0N/A if (!skip_fillInStackTrace_check) {

0N/A // check "fillInStackTrace" only once, so we negate the flag

0N/A // after the first time check.

0N/A skip_fillInStackTrace_check = true;

0N/A if (method->name() == vmSymbols::fillInStackTrace_name()) {

0N/A continue;

0N/A }

0N/A }

0N/A // skip <init> methods of the exceptions klass. If there is <init> methods

0N/A // that belongs to a superclass of the exception we are going to skipping

0N/A // them in stack trace. This is simlar to classic VM.

0N/A if (!skip_throwableInit_check) {

0N/A if (method->name() == vmSymbols::object_initializer_name() &&

0N/A throwable->is_a(method->method_holder())) {

0N/A continue;

0N/A } else {

0N/A // if no "Throwable.init()" method found, we stop checking it next time.

0N/A skip_throwableInit_check = true;

0N/A }

0N/A }

0N/A bt.push(method, bci, CHECK);

0N/A total_count++;

0N/A }

0N/A

0N/A // Put completed stack trace into throwable object

0N/A set_backtrace(throwable(), bt.backtrace());

0N/A}

0N/A

0N/Avoid java_lang_Throwable::fill_in_stack_trace(Handle throwable) {

0N/A // No-op if stack trace is disabled

0N/A if (!StackTraceInThrowable) {

0N/A return;

0N/A }

0N/A

0N/A // Disable stack traces for some preallocated out of memory errors

0N/A if (!Universe::should_fill_in_stack_trace(throwable)) {

0N/A return;

0N/A }

0N/A

0N/A PRESERVE_EXCEPTION_MARK;

0N/A

0N/A JavaThread* thread = JavaThread::active();

0N/A fill_in_stack_trace(throwable, thread);

0N/A // ignore exceptions thrown during stack trace filling

0N/A CLEAR_PENDING_EXCEPTION;

0N/A}

0N/A

0N/Avoid java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) {

0N/A // Allocate stack trace - backtrace is created but not filled in

0N/A

0N/A // No-op if stack trace is disabled

0N/A if (!StackTraceInThrowable) return;

0N/A

0N/A objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK);

0N/A objArrayHandle backtrace (THREAD, h_oop);

0N/A objArrayOop m_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK);

0N/A objArrayHandle methods (THREAD, m_oop);

0N/A typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK);

0N/A typeArrayHandle bcis(THREAD, b);

0N/A

0N/A // backtrace has space for one chunk (next is NULL)

0N/A backtrace->obj_at_put(trace_methods_offset, methods());

0N/A backtrace->obj_at_put(trace_bcis_offset, bcis());

0N/A set_backtrace(throwable(), backtrace());

0N/A}

0N/A

0N/A