1501 if (msg != NULL) {
1502 st->print(": %s", java_lang_String::as_utf8_string(msg));
1503 }
1504 }
1505
1506
1507 void java_lang_Throwable::print(Handle throwable, outputStream* st) {
1508 ResourceMark rm;
1509 Klass* k = throwable->klass();
1510 assert(k != NULL, "just checking");
1511 st->print("%s", k->external_name());
1512 oop msg = message(throwable);
1513 if (msg != NULL) {
1514 st->print(": %s", java_lang_String::as_utf8_string(msg));
1515 }
1516 }
1517
1518 // After this many redefines, the stack trace is unreliable.
1519 const int MAX_VERSION = USHRT_MAX;
1520
1521 // Helper backtrace functions to store bci|version together.
1522 static inline int merge_bci_and_version(int bci, int version) {
1523 // only store u2 for version, checking for overflow.
1524 if (version > USHRT_MAX || version < 0) version = MAX_VERSION;
1525 assert((jushort)bci == bci, "bci should be short");
1526 return build_int_from_shorts(version, bci);
1527 }
1528
1529 static inline int bci_at(unsigned int merged) {
1530 return extract_high_short_from_int(merged);
1531 }
1532 static inline int version_at(unsigned int merged) {
1533 return extract_low_short_from_int(merged);
1534 }
1535
1536 static inline bool version_matches(Method* method, int version) {
1537 assert(version < MAX_VERSION, "version is too big");
1538 return method != NULL && (method->constants()->version() == version);
1539 }
1540
1541 static inline int get_line_number(Method* method, int bci) {
1542 int line_number = 0;
1543 if (method->is_native()) {
1544 // Negative value different from -1 below, enabling Java code in
1545 // class java.lang.StackTraceElement to distinguish "native" from
1546 // "no LineNumberTable". JDK tests for -2.
1547 line_number = -2;
1548 } else {
1549 // Returns -1 if no LineNumberTable, and otherwise actual line number
1550 line_number = method->line_number_from_bci(bci);
1551 if (line_number == -1 && ShowHiddenFrames) {
1552 line_number = bci + 1000000;
1553 }
1554 }
1555 return line_number;
1556 }
1557
1558 // This class provides a simple wrapper over the internal structure of
1559 // exception backtrace to insulate users of the backtrace from needing
1560 // to know what it looks like.
1561 class BacktraceBuilder: public StackObj {
1562 private:
1563 Handle _backtrace;
1564 objArrayOop _head;
1565 typeArrayOop _methods;
1566 typeArrayOop _bcis;
1567 objArrayOop _mirrors;
1568 typeArrayOop _cprefs; // needed to insulate method name against redefinition
1569 int _index;
1570 No_Safepoint_Verifier _nsv;
1571
1572 public:
1573
1574 enum {
1575 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1576 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1577 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1659 _index = 0;
1660 }
1661
1662 oop backtrace() {
1663 return _backtrace();
1664 }
1665
1666 inline void push(Method* method, int bci, TRAPS) {
1667 // Smear the -1 bci to 0 since the array only holds unsigned
1668 // shorts. The later line number lookup would just smear the -1
1669 // to a 0 even if it could be recorded.
1670 if (bci == SynchronizationEntryBCI) bci = 0;
1671
1672 if (_index >= trace_chunk_size) {
1673 methodHandle mhandle(THREAD, method);
1674 expand(CHECK);
1675 method = mhandle();
1676 }
1677
1678 _methods->short_at_put(_index, method->orig_method_idnum());
1679 _bcis->int_at_put(_index, merge_bci_and_version(bci, method->constants()->version()));
1680 _cprefs->short_at_put(_index, method->name_index());
1681
1682 // We need to save the mirrors in the backtrace to keep the class
1683 // from being unloaded while we still have this stack trace.
1684 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1685 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1686 _index++;
1687 }
1688
1689 };
1690
1691 Symbol* get_source_file_name(InstanceKlass* holder, int version) {
1692 // Find the specific ik version that contains this source_file_name_index
1693 // via the previous versions list, but use the current version's
1694 // constant pool to look it up. The previous version's index has been
1695 // merged for the current constant pool.
1696 InstanceKlass* ik = holder->get_klass_version(version);
1697 // This version has been cleaned up.
1698 if (ik == NULL) return NULL;
1699 int source_file_name_index = ik->source_file_name_index();
1700 return (source_file_name_index == 0) ?
1701 (Symbol*)NULL : holder->constants()->symbol_at(source_file_name_index);
1702 }
1703
1704 // Print stack trace element to resource allocated buffer
1705 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
1706 int method_id, int version, int bci, int cpref) {
1707
1708 // Get strings and string lengths
1709 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1710 const char* klass_name = holder->external_name();
1711 int buf_len = (int)strlen(klass_name);
1712
1713 Method* method = holder->method_with_orig_idnum(method_id, version);
1714
1715 // The method can be NULL if the requested class version is gone
1716 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1717 char* method_name = sym->as_C_string();
1718 buf_len += (int)strlen(method_name);
1719
1720 char* source_file_name = NULL;
1721 Symbol* source = get_source_file_name(holder, version);
1722 if (source != NULL) {
1723 source_file_name = source->as_C_string();
1724 buf_len += (int)strlen(source_file_name);
1725 }
1726
1727 // Allocate temporary buffer with extra space for formatting and line number
1728 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);
1729
1730 // Print stack trace line in buffer
1731 sprintf(buf, "\tat %s.%s", klass_name, method_name);
1732
1733 if (!version_matches(method, version)) {
1734 strcat(buf, "(Redefined)");
1735 } else {
1736 int line_number = get_line_number(method, bci);
1737 if (line_number == -2) {
1738 strcat(buf, "(Native Method)");
1739 } else {
1740 if (source_file_name != NULL && (line_number != -1)) {
1741 // Sourcename and linenumber
1742 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1743 } else if (source_file_name != NULL) {
1744 // Just sourcename
1745 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1746 } else {
1747 // Neither sourcename nor linenumber
1748 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1749 }
1750 nmethod* nm = method->code();
1751 if (WizardMode && nm != NULL) {
1752 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1753 }
1754 }
1755 }
1756
1785 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
1786 if (result.is_null()) {
1787 st->print_raw_cr(no_stack_trace_message());
1788 return;
1789 }
1790
1791 while (result.not_null()) {
1792
1793 // Get method id, bci, version and mirror from chunk
1794 typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
1795 typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
1796 objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
1797 typeArrayHandle cprefs (THREAD, BacktraceBuilder::get_cprefs(result));
1798
1799 int length = methods()->length();
1800 for (int index = 0; index < length; index++) {
1801 Handle mirror(THREAD, mirrors->obj_at(index));
1802 // NULL mirror means end of stack trace
1803 if (mirror.is_null()) goto handle_cause;
1804 int method = methods->short_at(index);
1805 int version = version_at(bcis->int_at(index));
1806 int bci = bci_at(bcis->int_at(index));
1807 int cpref = cprefs->short_at(index);
1808 print_stack_element(st, mirror, method, version, bci, cpref);
1809 }
1810 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
1811 }
1812 handle_cause:
1813 {
1814 EXCEPTION_MARK;
1815 JavaValue cause(T_OBJECT);
1816 JavaCalls::call_virtual(&cause,
1817 h_throwable,
1818 KlassHandle(THREAD, h_throwable->klass()),
1819 vmSymbols::getCause_name(),
1820 vmSymbols::void_throwable_signature(),
1821 THREAD);
1822 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1823 if (HAS_PENDING_EXCEPTION) {
1824 CLEAR_PENDING_EXCEPTION;
1825 h_throwable = Handle();
1826 } else {
2073 // Compute how many chunks to skip and index into actual chunk
2074 objArrayOop chunk = objArrayOop(backtrace(throwable));
2075 int skip_chunks = index / trace_chunk_size;
2076 int chunk_index = index % trace_chunk_size;
2077 while (chunk != NULL && skip_chunks > 0) {
2078 chunk = objArrayOop(chunk->obj_at(trace_next_offset));
2079 skip_chunks--;
2080 }
2081 if (chunk == NULL) {
2082 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2083 }
2084 // Get method id, bci, version, mirror and cpref from chunk
2085 typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
2086 typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
2087 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
2088 typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
2089
2090 assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
2091
2092 int method = methods->short_at(chunk_index);
2093 int version = version_at(bcis->int_at(chunk_index));
2094 int bci = bci_at(bcis->int_at(chunk_index));
2095 int cpref = cprefs->short_at(chunk_index);
2096 Handle mirror(THREAD, mirrors->obj_at(chunk_index));
2097
2098 // Chunk can be partial full
2099 if (mirror.is_null()) {
2100 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2101 }
2102 oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, cpref, CHECK_0);
2103 return element;
2104 }
2105
2106 oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
2107 int version, int bci, int cpref, TRAPS) {
2108 // Allocate java.lang.StackTraceElement instance
2109 Klass* k = SystemDictionary::StackTraceElement_klass();
2110 assert(k != NULL, "must be loaded in 1.4+");
2111 instanceKlassHandle ik (THREAD, k);
2112 if (ik->should_be_initialized()) {
2113 ik->initialize(CHECK_0);
2114 }
2115
2116 Handle element = ik->allocate_instance_handle(CHECK_0);
2117 // Fill in class name
2118 ResourceMark rm(THREAD);
2119 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
2120 const char* str = holder->external_name();
2121 oop classname = StringTable::intern((char*) str, CHECK_0);
2122 java_lang_StackTraceElement::set_declaringClass(element(), classname);
2123
2124 Method* method = holder->method_with_orig_idnum(method_id, version);
2125
2126 // The method can be NULL if the requested class version is gone
2127 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
2128
2129 // Fill in method name
2130 oop methodname = StringTable::intern(sym, CHECK_0);
2131 java_lang_StackTraceElement::set_methodName(element(), methodname);
2132
2133 if (!version_matches(method, version)) {
2134 // The method was redefined, accurate line number information isn't available
2135 java_lang_StackTraceElement::set_fileName(element(), NULL);
2136 java_lang_StackTraceElement::set_lineNumber(element(), -1);
2137 } else {
2138 // Fill in source file name and line number.
2139 Symbol* source = get_source_file_name(holder, version);
2140 if (ShowHiddenFrames && source == NULL)
2141 source = vmSymbols::unknown_class_name();
2142 oop filename = StringTable::intern(source, CHECK_0);
2143 java_lang_StackTraceElement::set_fileName(element(), filename);
2144
2145 int line_number = get_line_number(method, bci);
2146 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
2147 }
2148 return element();
2149 }
2150
2151 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
2152 Handle mirror (THREAD, method->method_holder()->java_mirror());
2153 int method_id = method->orig_method_idnum();
2154 int cpref = method->name_index();
2155 return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
2156 }
2157
2158 void java_lang_reflect_AccessibleObject::compute_offsets() {
2159 Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
2160 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
2161 }
2162
2163 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
2164 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2165 return (jboolean) reflect->bool_field(override_offset);
2166 }
2167
2168 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
2169 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2170 reflect->bool_field_put(override_offset, (int) value);
2171 }
2172
2173 void java_lang_reflect_Method::compute_offsets() {
2174 Klass* k = SystemDictionary::reflect_Method_klass();
2175 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
2176 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
2177 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
3454 int java_lang_boxing_object::value_offset;
3455 int java_lang_boxing_object::long_value_offset;
3456 int java_lang_ref_Reference::referent_offset;
3457 int java_lang_ref_Reference::queue_offset;
3458 int java_lang_ref_Reference::next_offset;
3459 int java_lang_ref_Reference::discovered_offset;
3460 int java_lang_ref_Reference::static_lock_offset;
3461 int java_lang_ref_Reference::static_pending_offset;
3462 int java_lang_ref_Reference::number_of_fake_oop_fields;
3463 int java_lang_ref_SoftReference::timestamp_offset;
3464 int java_lang_ref_SoftReference::static_clock_offset;
3465 int java_lang_ClassLoader::parent_offset;
3466 int java_lang_System::static_in_offset;
3467 int java_lang_System::static_out_offset;
3468 int java_lang_System::static_err_offset;
3469 int java_lang_System::static_security_offset;
3470 int java_lang_StackTraceElement::declaringClass_offset;
3471 int java_lang_StackTraceElement::methodName_offset;
3472 int java_lang_StackTraceElement::fileName_offset;
3473 int java_lang_StackTraceElement::lineNumber_offset;
3474 int java_lang_AssertionStatusDirectives::classes_offset;
3475 int java_lang_AssertionStatusDirectives::classEnabled_offset;
3476 int java_lang_AssertionStatusDirectives::packages_offset;
3477 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
3478 int java_lang_AssertionStatusDirectives::deflt_offset;
3479 int java_nio_Buffer::_limit_offset;
3480 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0;
3481 int sun_reflect_ConstantPool::_oop_offset;
3482 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset;
3483
3484
3485 // Support for java_lang_StackTraceElement
3486
3487 void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
3488 element->obj_field_put(fileName_offset, value);
3489 }
3490
3491 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
3492 element->obj_field_put(declaringClass_offset, value);
3493 }
3494
3495 void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
3496 element->obj_field_put(methodName_offset, value);
3497 }
3498
3499 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
3500 element->int_field_put(lineNumber_offset, value);
3501 }
3502
3503
3504 // Support for java Assertions - java_lang_AssertionStatusDirectives.
3505
3506 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
3507 o->obj_field_put(classes_offset, val);
3508 }
3509
3510 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
3511 o->obj_field_put(classEnabled_offset, val);
3512 }
3513
3514 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
3515 o->obj_field_put(packages_offset, val);
3516 }
3517
3518 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
3519 o->obj_field_put(packageEnabled_offset, val);
3520 }
3521
3522 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
3616 java_lang_invoke_MethodHandle::compute_offsets();
3617 java_lang_invoke_DirectMethodHandle::compute_offsets();
3618 java_lang_invoke_MemberName::compute_offsets();
3619 java_lang_invoke_LambdaForm::compute_offsets();
3620 java_lang_invoke_MethodType::compute_offsets();
3621 java_lang_invoke_CallSite::compute_offsets();
3622 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets();
3623 java_security_AccessControlContext::compute_offsets();
3624 // Initialize reflection classes. The layouts of these classes
3625 // changed with the new reflection implementation in JDK 1.4, and
3626 // since the Universe doesn't know what JDK version it is until this
3627 // point we defer computation of these offsets until now.
3628 java_lang_reflect_AccessibleObject::compute_offsets();
3629 java_lang_reflect_Method::compute_offsets();
3630 java_lang_reflect_Constructor::compute_offsets();
3631 java_lang_reflect_Field::compute_offsets();
3632 java_nio_Buffer::compute_offsets();
3633 sun_reflect_ConstantPool::compute_offsets();
3634 sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
3635 java_lang_reflect_Parameter::compute_offsets();
3636
3637 // generated interpreter code wants to know about the offsets we just computed:
3638 AbstractAssembler::update_delayed_values();
3639 }
3640
3641 #ifndef PRODUCT
3642
3643 // These functions exist to assert the validity of hard-coded field offsets to guard
3644 // against changes in the class files
3645
3646 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
3647 EXCEPTION_MARK;
3648 fieldDescriptor fd;
3649 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3650 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
3651 instanceKlassHandle h_klass (THREAD, k);
3652 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
3653 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
3654 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
3655 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
|
1501 if (msg != NULL) {
1502 st->print(": %s", java_lang_String::as_utf8_string(msg));
1503 }
1504 }
1505
1506
1507 void java_lang_Throwable::print(Handle throwable, outputStream* st) {
1508 ResourceMark rm;
1509 Klass* k = throwable->klass();
1510 assert(k != NULL, "just checking");
1511 st->print("%s", k->external_name());
1512 oop msg = message(throwable);
1513 if (msg != NULL) {
1514 st->print(": %s", java_lang_String::as_utf8_string(msg));
1515 }
1516 }
1517
1518 // After this many redefines, the stack trace is unreliable.
1519 const int MAX_VERSION = USHRT_MAX;
1520
1521 static inline bool version_matches(Method* method, int version) {
1522 assert(version < MAX_VERSION, "version is too big");
1523 return method != NULL && (method->constants()->version() == version);
1524 }
1525
1526 // This class provides a simple wrapper over the internal structure of
1527 // exception backtrace to insulate users of the backtrace from needing
1528 // to know what it looks like.
1529 class BacktraceBuilder: public StackObj {
1530 private:
1531 Handle _backtrace;
1532 objArrayOop _head;
1533 typeArrayOop _methods;
1534 typeArrayOop _bcis;
1535 objArrayOop _mirrors;
1536 typeArrayOop _cprefs; // needed to insulate method name against redefinition
1537 int _index;
1538 No_Safepoint_Verifier _nsv;
1539
1540 public:
1541
1542 enum {
1543 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1544 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1545 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1627 _index = 0;
1628 }
1629
1630 oop backtrace() {
1631 return _backtrace();
1632 }
1633
1634 inline void push(Method* method, int bci, TRAPS) {
1635 // Smear the -1 bci to 0 since the array only holds unsigned
1636 // shorts. The later line number lookup would just smear the -1
1637 // to a 0 even if it could be recorded.
1638 if (bci == SynchronizationEntryBCI) bci = 0;
1639
1640 if (_index >= trace_chunk_size) {
1641 methodHandle mhandle(THREAD, method);
1642 expand(CHECK);
1643 method = mhandle();
1644 }
1645
1646 _methods->short_at_put(_index, method->orig_method_idnum());
1647 _bcis->int_at_put(_index, BackTrace::merge_bci_and_version(bci, method->constants()->version()));
1648 _cprefs->short_at_put(_index, method->name_index());
1649
1650 // We need to save the mirrors in the backtrace to keep the class
1651 // from being unloaded while we still have this stack trace.
1652 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1653 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1654 _index++;
1655 }
1656
1657 };
1658
1659 // Print stack trace element to resource allocated buffer
1660 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
1661 int method_id, int version, int bci, int cpref) {
1662
1663 // Get strings and string lengths
1664 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1665 const char* klass_name = holder->external_name();
1666 int buf_len = (int)strlen(klass_name);
1667
1668 Method* method = holder->method_with_orig_idnum(method_id, version);
1669
1670 // The method can be NULL if the requested class version is gone
1671 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1672 char* method_name = sym->as_C_string();
1673 buf_len += (int)strlen(method_name);
1674
1675 char* source_file_name = NULL;
1676 Symbol* source = BackTrace::get_source_file_name(holder, version);
1677 if (source != NULL) {
1678 source_file_name = source->as_C_string();
1679 buf_len += (int)strlen(source_file_name);
1680 }
1681
1682 // Allocate temporary buffer with extra space for formatting and line number
1683 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);
1684
1685 // Print stack trace line in buffer
1686 sprintf(buf, "\tat %s.%s", klass_name, method_name);
1687
1688 if (!version_matches(method, version)) {
1689 strcat(buf, "(Redefined)");
1690 } else {
1691 int line_number = BackTrace::get_line_number(method, bci);
1692 if (line_number == -2) {
1693 strcat(buf, "(Native Method)");
1694 } else {
1695 if (source_file_name != NULL && (line_number != -1)) {
1696 // Sourcename and linenumber
1697 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1698 } else if (source_file_name != NULL) {
1699 // Just sourcename
1700 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1701 } else {
1702 // Neither sourcename nor linenumber
1703 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1704 }
1705 nmethod* nm = method->code();
1706 if (WizardMode && nm != NULL) {
1707 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1708 }
1709 }
1710 }
1711
1740 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
1741 if (result.is_null()) {
1742 st->print_raw_cr(no_stack_trace_message());
1743 return;
1744 }
1745
1746 while (result.not_null()) {
1747
1748 // Get method id, bci, version and mirror from chunk
1749 typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
1750 typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
1751 objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
1752 typeArrayHandle cprefs (THREAD, BacktraceBuilder::get_cprefs(result));
1753
1754 int length = methods()->length();
1755 for (int index = 0; index < length; index++) {
1756 Handle mirror(THREAD, mirrors->obj_at(index));
1757 // NULL mirror means end of stack trace
1758 if (mirror.is_null()) goto handle_cause;
1759 int method = methods->short_at(index);
1760 int version = BackTrace::version_at(bcis->int_at(index));
1761 int bci = BackTrace::bci_at(bcis->int_at(index));
1762 int cpref = cprefs->short_at(index);
1763 print_stack_element(st, mirror, method, version, bci, cpref);
1764 }
1765 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
1766 }
1767 handle_cause:
1768 {
1769 EXCEPTION_MARK;
1770 JavaValue cause(T_OBJECT);
1771 JavaCalls::call_virtual(&cause,
1772 h_throwable,
1773 KlassHandle(THREAD, h_throwable->klass()),
1774 vmSymbols::getCause_name(),
1775 vmSymbols::void_throwable_signature(),
1776 THREAD);
1777 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1778 if (HAS_PENDING_EXCEPTION) {
1779 CLEAR_PENDING_EXCEPTION;
1780 h_throwable = Handle();
1781 } else {
2028 // Compute how many chunks to skip and index into actual chunk
2029 objArrayOop chunk = objArrayOop(backtrace(throwable));
2030 int skip_chunks = index / trace_chunk_size;
2031 int chunk_index = index % trace_chunk_size;
2032 while (chunk != NULL && skip_chunks > 0) {
2033 chunk = objArrayOop(chunk->obj_at(trace_next_offset));
2034 skip_chunks--;
2035 }
2036 if (chunk == NULL) {
2037 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2038 }
2039 // Get method id, bci, version, mirror and cpref from chunk
2040 typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
2041 typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
2042 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
2043 typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
2044
2045 assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
2046
2047 int method = methods->short_at(chunk_index);
2048 int version = BackTrace::version_at(bcis->int_at(chunk_index));
2049 int bci = BackTrace::bci_at(bcis->int_at(chunk_index));
2050 int cpref = cprefs->short_at(chunk_index);
2051 Handle mirror(THREAD, mirrors->obj_at(chunk_index));
2052
2053 // Chunk can be partial full
2054 if (mirror.is_null()) {
2055 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2056 }
2057 oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, cpref, CHECK_0);
2058 return element;
2059 }
2060
2061 oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
2062 int version, int bci, int cpref, TRAPS) {
2063 // Allocate java.lang.StackTraceElement instance
2064 Klass* k = SystemDictionary::StackTraceElement_klass();
2065 assert(k != NULL, "must be loaded in 1.4+");
2066 instanceKlassHandle ik (THREAD, k);
2067 if (ik->should_be_initialized()) {
2068 ik->initialize(CHECK_0);
2069 }
2070
2071 Handle element = ik->allocate_instance_handle(CHECK_0);
2072
2073 // Fill in class name
2074 ResourceMark rm(THREAD);
2075 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
2076 const char* str = holder->external_name();
2077 oop classname = StringTable::intern((char*) str, CHECK_0);
2078 java_lang_StackTraceElement::set_declaringClass(element(), classname);
2079
2080 Method* method = holder->method_with_orig_idnum(method_id, version);
2081
2082 // The method can be NULL if the requested class version is gone
2083 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
2084
2085 // Fill in method name
2086 oop methodname = StringTable::intern(sym, CHECK_0);
2087 java_lang_StackTraceElement::set_methodName(element(), methodname);
2088
2089 if (!version_matches(method, version)) {
2090 // The method was redefined, accurate line number information isn't available
2091 java_lang_StackTraceElement::set_fileName(element(), NULL);
2092 java_lang_StackTraceElement::set_lineNumber(element(), -1);
2093 } else {
2094 // Fill in source file name and line number.
2095 Symbol* source = BackTrace::get_source_file_name(holder, version);
2096 if (ShowHiddenFrames && source == NULL)
2097 source = vmSymbols::unknown_class_name();
2098 oop filename = StringTable::intern(source, CHECK_0);
2099 java_lang_StackTraceElement::set_fileName(element(), filename);
2100
2101 int line_number = BackTrace::get_line_number(method, bci);
2102 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
2103 }
2104 return element();
2105 }
2106
2107 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
2108 Handle mirror (THREAD, method->method_holder()->java_mirror());
2109 int method_id = method->orig_method_idnum();
2110 int cpref = method->name_index();
2111 return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
2112 }
2113
2114 Method* java_lang_StackFrameInfo::get_method(Handle stackFrame, InstanceKlass* holder, TRAPS) {
2115 if (MemberNameInStackFrame) {
2116 Handle mname(THREAD, stackFrame->obj_field(_memberName_offset));
2117 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mname());
2118 // we should expand MemberName::name when Throwable uses StackTrace
2119 // MethodHandles::expand_MemberName(mname, MethodHandles::_suppress_defc|MethodHandles::_suppress_type, CHECK_NULL);
2120 return method;
2121 } else {
2122 short mid = stackFrame->short_field(_mid_offset);
2123 short version = stackFrame->short_field(_version_offset);
2124 return holder->method_with_orig_idnum(mid, version);
2125 }
2126 }
2127
2128 Symbol* java_lang_StackFrameInfo::get_file_name(Handle stackFrame, InstanceKlass* holder) {
2129 if (MemberNameInStackFrame) {
2130 return holder->source_file_name();
2131 } else {
2132 int bci = stackFrame->int_field(_bci_offset);
2133 short version = stackFrame->short_field(_version_offset);
2134
2135 return BackTrace::get_source_file_name(holder, version);
2136 }
2137 }
2138
2139 void java_lang_StackFrameInfo::set_method_and_bci(Handle stackFrame, const methodHandle& method, int bci) {
2140 if (MemberNameInStackFrame) {
2141 oop mname = stackFrame->obj_field(_memberName_offset);
2142 InstanceKlass* ik = method->method_holder();
2143 CallInfo info(method(), ik);
2144 MethodHandles::init_method_MemberName(mname, info);
2145 java_lang_StackFrameInfo::set_bci(stackFrame(), bci);
2146 } else {
2147 int mid = method->orig_method_idnum();
2148 int version = method->constants()->version();
2149 int cpref = method->name_index();
2150 assert((jushort)mid == mid, "mid should be short");
2151 assert((jushort)version == version, "version should be short");
2152 assert((jushort)cpref == cpref, "cpref should be short");
2153
2154 java_lang_StackFrameInfo::set_mid(stackFrame(), (short)mid);
2155 java_lang_StackFrameInfo::set_version(stackFrame(), (short)version);
2156 java_lang_StackFrameInfo::set_cpref(stackFrame(), (short)cpref);
2157 java_lang_StackFrameInfo::set_bci(stackFrame(), bci);
2158 }
2159 }
2160
2161 void java_lang_StackFrameInfo::fill_methodInfo(Handle stackFrame, TRAPS) {
2162 ResourceMark rm(THREAD);
2163 oop k = stackFrame->obj_field(_declaringClass_offset);
2164 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(k));
2165 Method* method = java_lang_StackFrameInfo::get_method(stackFrame, holder, CHECK);
2166 int bci = stackFrame->int_field(_bci_offset);
2167
2168 // The method can be NULL if the requested class version is gone
2169 Symbol* sym = (method != NULL) ? method->name() : NULL;
2170 if (MemberNameInStackFrame) {
2171 assert(sym != NULL, "MemberName must have method name");
2172 } else {
2173 // The method can be NULL if the requested class version is gone
2174 if (sym == NULL) {
2175 short cpref = stackFrame->short_field(_cpref_offset);
2176 sym = holder->constants()->symbol_at(cpref);
2177 }
2178 }
2179
2180 // set method name
2181 oop methodname = StringTable::intern(sym, CHECK);
2182 java_lang_StackFrameInfo::set_methodName(stackFrame(), methodname);
2183
2184 // set file name and line number
2185 Symbol* source = get_file_name(stackFrame, holder);
2186 if (source != NULL) {
2187 oop filename = StringTable::intern(source, CHECK);
2188 java_lang_StackFrameInfo::set_fileName(stackFrame(), filename);
2189 }
2190 if (method != NULL) {
2191 int line_number = BackTrace::get_line_number(method, bci);
2192 java_lang_StackFrameInfo::set_lineNumber(stackFrame(), line_number);
2193 }
2194 }
2195
2196 void java_lang_StackFrameInfo::compute_offsets() {
2197 Klass* k = SystemDictionary::StackFrameInfo_klass();
2198 compute_offset(_declaringClass_offset, k, vmSymbols::declaringClass_name(), vmSymbols::class_signature());
2199 compute_offset(_memberName_offset, k, vmSymbols::memberName_name(), vmSymbols::object_signature());
2200 compute_offset(_bci_offset, k, vmSymbols::bci_name(), vmSymbols::int_signature());
2201 compute_offset(_methodName_offset, k, vmSymbols::methodName_name(), vmSymbols::string_signature());
2202 compute_offset(_fileName_offset, k, vmSymbols::fileName_name(), vmSymbols::string_signature());
2203 compute_offset(_lineNumber_offset, k, vmSymbols::lineNumber_name(), vmSymbols::int_signature());
2204 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2205 }
2206
2207 void java_lang_LiveStackFrameInfo::compute_offsets() {
2208 Klass* k = SystemDictionary::LiveStackFrameInfo_klass();
2209 compute_offset(_monitors_offset, k, vmSymbols::monitors_name(), vmSymbols::object_array_signature());
2210 compute_offset(_locals_offset, k, vmSymbols::locals_name(), vmSymbols::object_array_signature());
2211 compute_offset(_operands_offset, k, vmSymbols::operands_name(), vmSymbols::object_array_signature());
2212 }
2213
2214 void java_lang_reflect_AccessibleObject::compute_offsets() {
2215 Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
2216 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
2217 }
2218
2219 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
2220 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2221 return (jboolean) reflect->bool_field(override_offset);
2222 }
2223
2224 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
2225 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2226 reflect->bool_field_put(override_offset, (int) value);
2227 }
2228
2229 void java_lang_reflect_Method::compute_offsets() {
2230 Klass* k = SystemDictionary::reflect_Method_klass();
2231 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
2232 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
2233 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
3510 int java_lang_boxing_object::value_offset;
3511 int java_lang_boxing_object::long_value_offset;
3512 int java_lang_ref_Reference::referent_offset;
3513 int java_lang_ref_Reference::queue_offset;
3514 int java_lang_ref_Reference::next_offset;
3515 int java_lang_ref_Reference::discovered_offset;
3516 int java_lang_ref_Reference::static_lock_offset;
3517 int java_lang_ref_Reference::static_pending_offset;
3518 int java_lang_ref_Reference::number_of_fake_oop_fields;
3519 int java_lang_ref_SoftReference::timestamp_offset;
3520 int java_lang_ref_SoftReference::static_clock_offset;
3521 int java_lang_ClassLoader::parent_offset;
3522 int java_lang_System::static_in_offset;
3523 int java_lang_System::static_out_offset;
3524 int java_lang_System::static_err_offset;
3525 int java_lang_System::static_security_offset;
3526 int java_lang_StackTraceElement::declaringClass_offset;
3527 int java_lang_StackTraceElement::methodName_offset;
3528 int java_lang_StackTraceElement::fileName_offset;
3529 int java_lang_StackTraceElement::lineNumber_offset;
3530 int java_lang_StackFrameInfo::_declaringClass_offset;
3531 int java_lang_StackFrameInfo::_memberName_offset;
3532 int java_lang_StackFrameInfo::_bci_offset;
3533 int java_lang_StackFrameInfo::_methodName_offset;
3534 int java_lang_StackFrameInfo::_fileName_offset;
3535 int java_lang_StackFrameInfo::_lineNumber_offset;
3536 int java_lang_StackFrameInfo::_mid_offset;
3537 int java_lang_StackFrameInfo::_version_offset;
3538 int java_lang_StackFrameInfo::_cpref_offset;
3539 int java_lang_LiveStackFrameInfo::_monitors_offset;
3540 int java_lang_LiveStackFrameInfo::_locals_offset;
3541 int java_lang_LiveStackFrameInfo::_operands_offset;
3542 int java_lang_AssertionStatusDirectives::classes_offset;
3543 int java_lang_AssertionStatusDirectives::classEnabled_offset;
3544 int java_lang_AssertionStatusDirectives::packages_offset;
3545 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
3546 int java_lang_AssertionStatusDirectives::deflt_offset;
3547 int java_nio_Buffer::_limit_offset;
3548 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0;
3549 int sun_reflect_ConstantPool::_oop_offset;
3550 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset;
3551
3552
3553 // Support for java_lang_StackTraceElement
3554
3555 void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
3556 element->obj_field_put(fileName_offset, value);
3557 }
3558
3559 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
3560 element->obj_field_put(declaringClass_offset, value);
3561 }
3562
3563 void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
3564 element->obj_field_put(methodName_offset, value);
3565 }
3566
3567 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
3568 element->int_field_put(lineNumber_offset, value);
3569 }
3570
3571 // Support for java_lang_StackFrameInfo
3572 void java_lang_StackFrameInfo::set_declaringClass(oop element, oop value) {
3573 element->obj_field_put(_declaringClass_offset, value);
3574 }
3575
3576 void java_lang_StackFrameInfo::set_mid(oop element, short value) {
3577 element->short_field_put(_mid_offset, value);
3578 }
3579
3580 void java_lang_StackFrameInfo::set_version(oop element, short value) {
3581 element->short_field_put(_version_offset, value);
3582 }
3583
3584 void java_lang_StackFrameInfo::set_cpref(oop element, short value) {
3585 element->short_field_put(_cpref_offset, value);
3586 }
3587
3588 void java_lang_StackFrameInfo::set_bci(oop element, int value) {
3589 element->int_field_put(_bci_offset, value);
3590 }
3591
3592 void java_lang_StackFrameInfo::set_fileName(oop element, oop value) {
3593 element->obj_field_put(_fileName_offset, value);
3594 }
3595
3596 void java_lang_StackFrameInfo::set_methodName(oop element, oop value) {
3597 element->obj_field_put(_methodName_offset, value);
3598 }
3599
3600 void java_lang_StackFrameInfo::set_lineNumber(oop element, int value) {
3601 element->int_field_put(_lineNumber_offset, value);
3602 }
3603
3604 void java_lang_LiveStackFrameInfo::set_monitors(oop element, oop value) {
3605 element->obj_field_put(_monitors_offset, value);
3606 }
3607
3608 void java_lang_LiveStackFrameInfo::set_locals(oop element, oop value) {
3609 element->obj_field_put(_locals_offset, value);
3610 }
3611
3612 void java_lang_LiveStackFrameInfo::set_operands(oop element, oop value) {
3613 element->obj_field_put(_operands_offset, value);
3614 }
3615
3616 // Support for java Assertions - java_lang_AssertionStatusDirectives.
3617
3618 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
3619 o->obj_field_put(classes_offset, val);
3620 }
3621
3622 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
3623 o->obj_field_put(classEnabled_offset, val);
3624 }
3625
3626 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
3627 o->obj_field_put(packages_offset, val);
3628 }
3629
3630 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
3631 o->obj_field_put(packageEnabled_offset, val);
3632 }
3633
3634 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
3728 java_lang_invoke_MethodHandle::compute_offsets();
3729 java_lang_invoke_DirectMethodHandle::compute_offsets();
3730 java_lang_invoke_MemberName::compute_offsets();
3731 java_lang_invoke_LambdaForm::compute_offsets();
3732 java_lang_invoke_MethodType::compute_offsets();
3733 java_lang_invoke_CallSite::compute_offsets();
3734 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets();
3735 java_security_AccessControlContext::compute_offsets();
3736 // Initialize reflection classes. The layouts of these classes
3737 // changed with the new reflection implementation in JDK 1.4, and
3738 // since the Universe doesn't know what JDK version it is until this
3739 // point we defer computation of these offsets until now.
3740 java_lang_reflect_AccessibleObject::compute_offsets();
3741 java_lang_reflect_Method::compute_offsets();
3742 java_lang_reflect_Constructor::compute_offsets();
3743 java_lang_reflect_Field::compute_offsets();
3744 java_nio_Buffer::compute_offsets();
3745 sun_reflect_ConstantPool::compute_offsets();
3746 sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
3747 java_lang_reflect_Parameter::compute_offsets();
3748 java_lang_StackFrameInfo::compute_offsets();
3749 java_lang_LiveStackFrameInfo::compute_offsets();
3750
3751 // generated interpreter code wants to know about the offsets we just computed:
3752 AbstractAssembler::update_delayed_values();
3753 }
3754
3755 #ifndef PRODUCT
3756
3757 // These functions exist to assert the validity of hard-coded field offsets to guard
3758 // against changes in the class files
3759
3760 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
3761 EXCEPTION_MARK;
3762 fieldDescriptor fd;
3763 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3764 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
3765 instanceKlassHandle h_klass (THREAD, k);
3766 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
3767 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
3768 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
3769 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
|