1422 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
1423 }
1424
1425 void java_lang_ThreadGroup::compute_offsets() {
1426 assert(_parent_offset == 0, "offsets should be initialized only once");
1427
1428 Klass* k = SystemDictionary::ThreadGroup_klass();
1429
1430 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
1431 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1432 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
1433 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
1434 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
1435 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
1436 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
1437 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
1438 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
1439 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
1440 }
1441
1442 oop java_lang_Throwable::unassigned_stacktrace() {
1443 InstanceKlass* ik = SystemDictionary::Throwable_klass();
1444 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset);
1445 if (UseCompressedOops) {
1446 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
1447 } else {
1448 return oopDesc::load_decode_heap_oop((oop*)addr);
1449 }
1450 }
1451
1452 oop java_lang_Throwable::backtrace(oop throwable) {
1453 return throwable->obj_field_acquire(backtrace_offset);
1454 }
1455
1456
1457 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
1458 throwable->release_obj_field_put(backtrace_offset, value);
1459 }
1460
1461
1462 oop java_lang_Throwable::message(oop throwable) {
1463 return throwable->obj_field(detailMessage_offset);
1464 }
1465
1466
1467 oop java_lang_Throwable::message(Handle throwable) {
1468 return throwable->obj_field(detailMessage_offset);
1469 }
1470
1471
1472 // Return Symbol for detailed_message or NULL
1473 Symbol* java_lang_Throwable::detail_message(oop throwable) {
1474 PRESERVE_EXCEPTION_MARK; // Keep original exception
1475 oop detailed_message = java_lang_Throwable::message(throwable);
1476 if (detailed_message != NULL) {
1477 return java_lang_String::as_symbol(detailed_message, THREAD);
1478 }
1479 return NULL;
1480 }
1481
1482 void java_lang_Throwable::set_message(oop throwable, oop value) {
1483 throwable->obj_field_put(detailMessage_offset, value);
1484 }
1485
1486
1495
1496 void java_lang_Throwable::print(Handle throwable, outputStream* st) {
1497 ResourceMark rm;
1498 Klass* k = throwable->klass();
1499 assert(k != NULL, "just checking");
1500 st->print("%s", k->external_name());
1501 oop msg = message(throwable);
1502 if (msg != NULL) {
1503 st->print(": %s", java_lang_String::as_utf8_string(msg));
1504 }
1505 }
1506
1507 // After this many redefines, the stack trace is unreliable.
1508 const int MAX_VERSION = USHRT_MAX;
1509
1510 static inline bool version_matches(Method* method, int version) {
1511 assert(version < MAX_VERSION, "version is too big");
1512 return method != NULL && (method->constants()->version() == version);
1513 }
1514
1515 // This class provides a simple wrapper over the internal structure of
1516 // exception backtrace to insulate users of the backtrace from needing
1517 // to know what it looks like.
1518 class BacktraceBuilder: public StackObj {
1519 private:
1520 Handle _backtrace;
1521 objArrayOop _head;
1522 typeArrayOop _methods;
1523 typeArrayOop _bcis;
1524 objArrayOop _mirrors;
1525 typeArrayOop _cprefs; // needed to insulate method name against redefinition
1526 int _index;
1527 NoSafepointVerifier _nsv;
1528
1529 public:
1530
1531 enum {
1532 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1533 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1534 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1535 trace_cprefs_offset = java_lang_Throwable::trace_cprefs_offset,
1536 trace_next_offset = java_lang_Throwable::trace_next_offset,
1537 trace_size = java_lang_Throwable::trace_size,
1538 trace_chunk_size = java_lang_Throwable::trace_chunk_size
1539 };
1540
1541 // get info out of chunks
1542 static typeArrayOop get_methods(objArrayHandle chunk) {
1543 typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset));
1544 assert(methods != NULL, "method array should be initialized in backtrace");
1545 return methods;
1546 }
1547 static typeArrayOop get_bcis(objArrayHandle chunk) {
1548 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1549 assert(bcis != NULL, "bci array should be initialized in backtrace");
1550 return bcis;
1551 }
1552 static objArrayOop get_mirrors(objArrayHandle chunk) {
1553 objArrayOop mirrors = objArrayOop(chunk->obj_at(trace_mirrors_offset));
1554 assert(mirrors != NULL, "mirror array should be initialized in backtrace");
1555 return mirrors;
1556 }
1557 static typeArrayOop get_cprefs(objArrayHandle chunk) {
1558 typeArrayOop cprefs = typeArrayOop(chunk->obj_at(trace_cprefs_offset));
1559 assert(cprefs != NULL, "cprefs array should be initialized in backtrace");
1560 return cprefs;
1561 }
1562
1563 // constructor for new backtrace
1564 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _cprefs(NULL) {
1565 expand(CHECK);
1566 _backtrace = _head;
1567 _index = 0;
1568 }
1569
1570 BacktraceBuilder(objArrayHandle backtrace) {
1571 _methods = get_methods(backtrace);
1572 _bcis = get_bcis(backtrace);
1573 _mirrors = get_mirrors(backtrace);
1574 _cprefs = get_cprefs(backtrace);
1575 assert(_methods->length() == _bcis->length() &&
1576 _methods->length() == _mirrors->length(),
1577 "method and source information arrays should match");
1578
1579 // head is the preallocated backtrace
1580 _backtrace = _head = backtrace();
1581 _index = 0;
1582 }
1628
1629 if (_index >= trace_chunk_size) {
1630 methodHandle mhandle(THREAD, method);
1631 expand(CHECK);
1632 method = mhandle();
1633 }
1634
1635 _methods->short_at_put(_index, method->orig_method_idnum());
1636 _bcis->int_at_put(_index, Backtrace::merge_bci_and_version(bci, method->constants()->version()));
1637 _cprefs->short_at_put(_index, method->name_index());
1638
1639 // We need to save the mirrors in the backtrace to keep the class
1640 // from being unloaded while we still have this stack trace.
1641 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1642 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1643 _index++;
1644 }
1645
1646 };
1647
1648 // Print stack trace element to resource allocated buffer
1649 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
1650 int method_id, int version, int bci, int cpref) {
1651
1652 // Get strings and string lengths
1653 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1654 const char* klass_name = holder->external_name();
1655 int buf_len = (int)strlen(klass_name);
1656
1657 Method* method = holder->method_with_orig_idnum(method_id, version);
1658
1659 // The method can be NULL if the requested class version is gone
1660 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1661 char* method_name = sym->as_C_string();
1662 buf_len += (int)strlen(method_name);
1663
1664 char* source_file_name = NULL;
1665 Symbol* source = Backtrace::get_source_file_name(holder, version);
1666 if (source != NULL) {
1667 source_file_name = source->as_C_string();
1668 buf_len += (int)strlen(source_file_name);
1669 }
1670
1681 if (line_number == -2) {
1682 strcat(buf, "(Native Method)");
1683 } else {
1684 if (source_file_name != NULL && (line_number != -1)) {
1685 // Sourcename and linenumber
1686 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1687 } else if (source_file_name != NULL) {
1688 // Just sourcename
1689 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1690 } else {
1691 // Neither sourcename nor linenumber
1692 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1693 }
1694 nmethod* nm = method->code();
1695 if (WizardMode && nm != NULL) {
1696 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1697 }
1698 }
1699 }
1700
1701 return buf;
1702 }
1703
1704 void java_lang_Throwable::print_stack_element(outputStream *st, Handle mirror,
1705 int method_id, int version, int bci, int cpref) {
1706 ResourceMark rm;
1707 char* buf = print_stack_element_to_buffer(mirror, method_id, version, bci, cpref);
1708 st->print_cr("%s", buf);
1709 }
1710
1711 void java_lang_Throwable::print_stack_element(outputStream *st, const methodHandle& method, int bci) {
1712 Handle mirror = method->method_holder()->java_mirror();
1713 int method_id = method->orig_method_idnum();
1714 int version = method->constants()->version();
1715 int cpref = method->name_index();
1716 print_stack_element(st, mirror, method_id, version, bci, cpref);
1717 }
1718
1719 const char* java_lang_Throwable::no_stack_trace_message() {
1720 return "\t<<no stack trace available>>";
1721 }
1722
1723 /**
1724 * Print the throwable message and its stack trace plus all causes by walking the
1725 * cause chain. The output looks the same as of Throwable.printStackTrace().
1726 */
1727 void java_lang_Throwable::print_stack_trace(Handle throwable, outputStream* st) {
1728 // First, print the message.
1729 print(throwable, st);
1730 st->cr();
1731
1732 // Now print the stack trace.
1733 Thread* THREAD = Thread::current();
1734 while (throwable.not_null()) {
1735 objArrayHandle result (THREAD, objArrayOop(backtrace(throwable())));
1736 if (result.is_null()) {
1737 st->print_raw_cr(no_stack_trace_message());
1738 return;
1739 }
1740
1741 while (result.not_null()) {
1742 // Get method id, bci, version and mirror from chunk
1743 typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
1744 typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
1745 objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
1746 typeArrayHandle cprefs (THREAD, BacktraceBuilder::get_cprefs(result));
1747
1748 int length = methods()->length();
1749 for (int index = 0; index < length; index++) {
1750 Handle mirror(THREAD, mirrors->obj_at(index));
1751 // NULL mirror means end of stack trace
1752 if (mirror.is_null()) goto handle_cause;
1753 int method = methods->short_at(index);
1754 int version = Backtrace::version_at(bcis->int_at(index));
1755 int bci = Backtrace::bci_at(bcis->int_at(index));
1756 int cpref = cprefs->short_at(index);
1757 print_stack_element(st, mirror, method, version, bci, cpref);
1758 }
1759 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
1760 }
1761 handle_cause:
1762 {
1763 EXCEPTION_MARK;
1764 JavaValue cause(T_OBJECT);
1765 JavaCalls::call_virtual(&cause,
1766 throwable,
1767 KlassHandle(THREAD, throwable->klass()),
1768 vmSymbols::getCause_name(),
1769 vmSymbols::void_throwable_signature(),
1770 THREAD);
1771 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1772 if (HAS_PENDING_EXCEPTION) {
1773 CLEAR_PENDING_EXCEPTION;
1774 throwable = Handle();
1775 } else {
1776 throwable = Handle(THREAD, (oop) cause.get_jobject());
1777 if (throwable.not_null()) {
1778 st->print("Caused by: ");
1779 print(throwable, st);
1780 st->cr();
1781 }
1782 }
1794 throwable,
1795 KlassHandle(THREAD, SystemDictionary::Throwable_klass()),
1796 vmSymbols::printStackTrace_name(),
1797 vmSymbols::void_method_signature(),
1798 THREAD);
1799 }
1800
1801 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method, TRAPS) {
1802 if (!StackTraceInThrowable) return;
1803 ResourceMark rm(THREAD);
1804
1805 // Start out by clearing the backtrace for this object, in case the VM
1806 // runs out of memory while allocating the stack trace
1807 set_backtrace(throwable(), NULL);
1808 // Clear lazily constructed Java level stacktrace if refilling occurs
1809 // This is unnecessary in 1.7+ but harmless
1810 clear_stacktrace(throwable());
1811
1812 int max_depth = MaxJavaStackTraceDepth;
1813 JavaThread* thread = (JavaThread*)THREAD;
1814 BacktraceBuilder bt(CHECK);
1815
1816 // If there is no Java frame just return the method that was being called
1817 // with bci 0
1818 if (!thread->has_last_Java_frame()) {
1819 if (max_depth >= 1 && method() != NULL) {
1820 bt.push(method(), 0, CHECK);
1821 set_backtrace(throwable(), bt.backtrace());
1822 }
1823 return;
1824 }
1825
1826 // Instead of using vframe directly, this version of fill_in_stack_trace
1827 // basically handles everything by hand. This significantly improved the
1828 // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows.
1829 // See bug 6333838 for more details.
1830 // The "ASSERT" here is to verify this method generates the exactly same stack
1831 // trace as utilizing vframe.
1832 #ifdef ASSERT
1833 vframeStream st(thread);
1834 methodHandle st_method(THREAD, st.method());
1835 #endif
1836 int total_count = 0;
1837 RegisterMap map(thread, false);
1838 int decode_offset = 0;
1839 nmethod* nm = NULL;
1840 bool skip_fillInStackTrace_check = false;
1908 if (!skip_throwableInit_check) {
1909 assert(skip_fillInStackTrace_check, "logic error in backtrace filtering");
1910
1911 // skip <init> methods of the exception class and superclasses
1912 // This is simlar to classic VM.
1913 if (method->name() == vmSymbols::object_initializer_name() &&
1914 throwable->is_a(method->method_holder())) {
1915 continue;
1916 } else {
1917 // there are none or we've seen them all - either way stop checking
1918 skip_throwableInit_check = true;
1919 }
1920 }
1921 if (method->is_hidden()) {
1922 if (skip_hidden) continue;
1923 }
1924 bt.push(method, bci, CHECK);
1925 total_count++;
1926 }
1927
1928 // Put completed stack trace into throwable object
1929 set_backtrace(throwable(), bt.backtrace());
1930 }
1931
1932 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method) {
1933 // No-op if stack trace is disabled
1934 if (!StackTraceInThrowable) {
1935 return;
1936 }
1937
1938 // Disable stack traces for some preallocated out of memory errors
1939 if (!Universe::should_fill_in_stack_trace(throwable)) {
1940 return;
1941 }
1942
1943 PRESERVE_EXCEPTION_MARK;
1944
1945 JavaThread* thread = JavaThread::active();
1946 fill_in_stack_trace(throwable, method, thread);
1947 // ignore exceptions thrown during stack trace filling
1948 CLEAR_PENDING_EXCEPTION;
1949 }
1963
1964 // No-op if stack trace is disabled
1965 if (!StackTraceInThrowable) return;
1966
1967 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check");
1968
1969 JavaThread* THREAD = JavaThread::current();
1970
1971 objArrayHandle backtrace (THREAD, (objArrayOop)java_lang_Throwable::backtrace(throwable()));
1972 assert(backtrace.not_null(), "backtrace should have been preallocated");
1973
1974 ResourceMark rm(THREAD);
1975 vframeStream st(THREAD);
1976
1977 BacktraceBuilder bt(backtrace);
1978
1979 // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init
1980 // methods as preallocated errors aren't created by "java" code.
1981
1982 // fill in as much stack trace as possible
1983 typeArrayOop methods = BacktraceBuilder::get_methods(backtrace);
1984 int max_chunks = MIN2(methods->length(), (int)MaxJavaStackTraceDepth);
1985 int chunk_count = 0;
1986
1987 for (;!st.at_end(); st.next()) {
1988 bt.push(st.method(), st.bci(), CHECK);
1989 chunk_count++;
1990
1991 // Bail-out for deep stacks
1992 if (chunk_count >= max_chunks) break;
1993 }
1994
1995 // We support the Throwable immutability protocol defined for Java 7.
1996 java_lang_Throwable::set_stacktrace(throwable(), java_lang_Throwable::unassigned_stacktrace());
1997 assert(java_lang_Throwable::unassigned_stacktrace() != NULL, "not initialized");
1998 }
1999
2000
2001 int java_lang_Throwable::get_stack_trace_depth(oop throwable, TRAPS) {
2002 if (throwable == NULL) {
2003 THROW_0(vmSymbols::java_lang_NullPointerException());
2004 }
2005 objArrayOop chunk = objArrayOop(backtrace(throwable));
2006 int depth = 0;
2007 if (chunk != NULL) {
2008 // Iterate over chunks and count full ones
2009 while (true) {
2010 objArrayOop next = objArrayOop(chunk->obj_at(trace_next_offset));
2011 if (next == NULL) break;
2012 depth += trace_chunk_size;
2013 chunk = next;
2014 }
2015 assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check");
2016 // Count element in remaining partial chunk. NULL value for mirror
2017 // marks the end of the stack trace elements that are saved.
2018 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
2019 assert(mirrors != NULL, "sanity check");
2020 for (int i = 0; i < mirrors->length(); i++) {
2021 if (mirrors->obj_at(i) == NULL) break;
2022 depth++;
2023 }
2024 }
2025 return depth;
2026 }
2027
2028
2029 oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) {
2030 if (throwable == NULL) {
2031 THROW_0(vmSymbols::java_lang_NullPointerException());
2032 }
2033 if (index < 0) {
2034 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2035 }
2036 // Compute how many chunks to skip and index into actual chunk
2037 objArrayOop chunk = objArrayOop(backtrace(throwable));
2038 int skip_chunks = index / trace_chunk_size;
2039 int chunk_index = index % trace_chunk_size;
2040 while (chunk != NULL && skip_chunks > 0) {
2041 chunk = objArrayOop(chunk->obj_at(trace_next_offset));
2042 skip_chunks--;
2043 }
2044 if (chunk == NULL) {
2045 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2046 }
2047 // Get method id, bci, version, mirror and cpref from chunk
2048 typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
2049 typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
2050 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
2051 typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
2052
2053 assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
2054
2055 int method = methods->short_at(chunk_index);
2056 int version = Backtrace::version_at(bcis->int_at(chunk_index));
2057 int bci = Backtrace::bci_at(bcis->int_at(chunk_index));
2058 int cpref = cprefs->short_at(chunk_index);
2059 Handle mirror(THREAD, mirrors->obj_at(chunk_index));
2060
2061 // Chunk can be partial full
2062 if (mirror.is_null()) {
2063 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
2064 }
2065 oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, cpref, CHECK_0);
2066 return element;
2067 }
2068
2069 oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
2070 int version, int bci, int cpref, TRAPS) {
2071 // Allocate java.lang.StackTraceElement instance
2072 Klass* k = SystemDictionary::StackTraceElement_klass();
2073 assert(k != NULL, "must be loaded in 1.4+");
2074 instanceKlassHandle ik (THREAD, k);
2075 if (ik->should_be_initialized()) {
2076 ik->initialize(CHECK_0);
2077 }
2078
2079 Handle element = ik->allocate_instance_handle(CHECK_0);
2080
2081 // Fill in class name
2082 ResourceMark rm(THREAD);
2083 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
2084 const char* str = holder->external_name();
2085 oop classname = StringTable::intern((char*) str, CHECK_0);
2086 java_lang_StackTraceElement::set_declaringClass(element(), classname);
2087
2088 Method* method = holder->method_with_orig_idnum(method_id, version);
2089
2090 // The method can be NULL if the requested class version is gone
2091 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
2092
2093 // Fill in method name
2094 oop methodname = StringTable::intern(sym, CHECK_0);
2095 java_lang_StackTraceElement::set_methodName(element(), methodname);
2096
2097 if (!version_matches(method, version)) {
2098 // The method was redefined, accurate line number information isn't available
2099 java_lang_StackTraceElement::set_fileName(element(), NULL);
2100 java_lang_StackTraceElement::set_lineNumber(element(), -1);
2101 } else {
2102 // Fill in source file name and line number.
2103 Symbol* source = Backtrace::get_source_file_name(holder, version);
2104 if (ShowHiddenFrames && source == NULL)
2105 source = vmSymbols::unknown_class_name();
2106 oop filename = StringTable::intern(source, CHECK_0);
2107 java_lang_StackTraceElement::set_fileName(element(), filename);
2108
2109 int line_number = Backtrace::get_line_number(method, bci);
2110 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
2111 }
2112 return element();
2113 }
2114
2115 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
2116 Handle mirror (THREAD, method->method_holder()->java_mirror());
2117 int method_id = method->orig_method_idnum();
2118 int cpref = method->name_index();
2119 return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
2120 }
2121
2122 Method* java_lang_StackFrameInfo::get_method(Handle stackFrame, InstanceKlass* holder, TRAPS) {
2123 if (MemberNameInStackFrame) {
2124 Handle mname(THREAD, stackFrame->obj_field(_memberName_offset));
2125 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mname());
2126 // we should expand MemberName::name when Throwable uses StackTrace
2127 // MethodHandles::expand_MemberName(mname, MethodHandles::_suppress_defc|MethodHandles::_suppress_type, CHECK_NULL);
2128 return method;
2129 } else {
2130 short mid = stackFrame->short_field(_mid_offset);
2131 short version = stackFrame->short_field(_version_offset);
2132 return holder->method_with_orig_idnum(mid, version);
2133 }
2134 }
2135
2136 Symbol* java_lang_StackFrameInfo::get_file_name(Handle stackFrame, InstanceKlass* holder) {
2137 if (MemberNameInStackFrame) {
2138 return holder->source_file_name();
2139 } else {
3460 address addr = ik->static_field_addr(static_security_offset);
3461 if (UseCompressedOops) {
3462 return oopDesc::load_decode_heap_oop((narrowOop *)addr) != NULL;
3463 } else {
3464 return oopDesc::load_decode_heap_oop((oop*)addr) != NULL;
3465 }
3466 }
3467
3468 int java_lang_Class::_klass_offset;
3469 int java_lang_Class::_array_klass_offset;
3470 int java_lang_Class::_oop_size_offset;
3471 int java_lang_Class::_static_oop_field_count_offset;
3472 int java_lang_Class::_class_loader_offset;
3473 int java_lang_Class::_protection_domain_offset;
3474 int java_lang_Class::_component_mirror_offset;
3475 int java_lang_Class::_init_lock_offset;
3476 int java_lang_Class::_signers_offset;
3477 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
3478 int java_lang_Throwable::backtrace_offset;
3479 int java_lang_Throwable::detailMessage_offset;
3480 int java_lang_Throwable::cause_offset;
3481 int java_lang_Throwable::stackTrace_offset;
3482 int java_lang_Throwable::static_unassigned_stacktrace_offset;
3483 int java_lang_reflect_AccessibleObject::override_offset;
3484 int java_lang_reflect_Method::clazz_offset;
3485 int java_lang_reflect_Method::name_offset;
3486 int java_lang_reflect_Method::returnType_offset;
3487 int java_lang_reflect_Method::parameterTypes_offset;
3488 int java_lang_reflect_Method::exceptionTypes_offset;
3489 int java_lang_reflect_Method::slot_offset;
3490 int java_lang_reflect_Method::modifiers_offset;
3491 int java_lang_reflect_Method::signature_offset;
3492 int java_lang_reflect_Method::annotations_offset;
3493 int java_lang_reflect_Method::parameter_annotations_offset;
3494 int java_lang_reflect_Method::annotation_default_offset;
3495 int java_lang_reflect_Method::type_annotations_offset;
3496 int java_lang_reflect_Constructor::clazz_offset;
3497 int java_lang_reflect_Constructor::parameterTypes_offset;
3498 int java_lang_reflect_Constructor::exceptionTypes_offset;
3499 int java_lang_reflect_Constructor::slot_offset;
3500 int java_lang_reflect_Constructor::modifiers_offset;
3501 int java_lang_reflect_Constructor::signature_offset;
3662 Klass* k = SystemDictionary::abstract_ownable_synchronizer_klass();
3663 compute_offset(_owner_offset, k,
3664 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
3665 }
3666
3667 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
3668 assert(_owner_offset != 0, "Must be initialized");
3669 return obj->obj_field(_owner_offset);
3670 }
3671
3672 // Compute hard-coded offsets
3673 // Invoked before SystemDictionary::initialize, so pre-loaded classes
3674 // are not available to determine the offset_of_static_fields.
3675 void JavaClasses::compute_hard_coded_offsets() {
3676 const int x = heapOopSize;
3677 const int header = instanceOopDesc::base_offset_in_bytes();
3678
3679 // Throwable Class
3680 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
3681 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
3682 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
3683 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
3684 java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset * x;
3685
3686 // java_lang_boxing_object
3687 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
3688 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
3689
3690 // java_lang_ref_Reference:
3691 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
3692 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
3693 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
3694 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
3695 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
3696 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
3697 // Artificial fields for java_lang_ref_Reference
3698 // The first field is for the discovered field added in 1.4
3699 java_lang_ref_Reference::number_of_fake_oop_fields = 1;
3700
3701 // java_lang_ref_SoftReference Class
3702 java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong);
3713 java_lang_System::static_security_offset = java_lang_System::hc_static_security_offset * x;
3714
3715 // java_lang_StackTraceElement
3716 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header;
3717 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
3718 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header;
3719 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
3720 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
3721 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
3722 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
3723 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
3724 java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header;
3725
3726 }
3727
3728
3729 // Compute non-hard-coded field offsets of all the classes in this file
3730 void JavaClasses::compute_offsets() {
3731 // java_lang_Class::compute_offsets was called earlier in bootstrap
3732 java_lang_ClassLoader::compute_offsets();
3733 java_lang_Thread::compute_offsets();
3734 java_lang_ThreadGroup::compute_offsets();
3735 java_lang_invoke_MethodHandle::compute_offsets();
3736 java_lang_invoke_DirectMethodHandle::compute_offsets();
3737 java_lang_invoke_MemberName::compute_offsets();
3738 java_lang_invoke_LambdaForm::compute_offsets();
3739 java_lang_invoke_MethodType::compute_offsets();
3740 java_lang_invoke_CallSite::compute_offsets();
3741 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets();
3742 java_security_AccessControlContext::compute_offsets();
3743 // Initialize reflection classes. The layouts of these classes
3744 // changed with the new reflection implementation in JDK 1.4, and
3745 // since the Universe doesn't know what JDK version it is until this
3746 // point we defer computation of these offsets until now.
3747 java_lang_reflect_AccessibleObject::compute_offsets();
3748 java_lang_reflect_Method::compute_offsets();
3749 java_lang_reflect_Constructor::compute_offsets();
3750 java_lang_reflect_Field::compute_offsets();
3751 java_nio_Buffer::compute_offsets();
3752 sun_reflect_ConstantPool::compute_offsets();
3866 // java.lang.String
3867
3868 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[B");
3869 if (java_lang_String::has_hash_field()) {
3870 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
3871 }
3872 if (java_lang_String::has_coder_field()) {
3873 CHECK_OFFSET("java/lang/String", java_lang_String, coder, "B");
3874 }
3875
3876 // java.lang.Class
3877
3878 // Fake fields
3879 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
3880 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
3881
3882 // java.lang.Throwable
3883
3884 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
3885 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
3886 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
3887 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
3888
3889 // Boxed primitive objects (java_lang_boxing_object)
3890
3891 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
3892 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
3893 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
3894 CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D");
3895 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B");
3896 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S");
3897 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I");
3898 CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J");
3899
3900 // java.lang.ClassLoader
3901
3902 CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;");
3903
3904 // java.lang.System
3905
3906 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;");
3907 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;");
|
1422 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
1423 }
1424
1425 void java_lang_ThreadGroup::compute_offsets() {
1426 assert(_parent_offset == 0, "offsets should be initialized only once");
1427
1428 Klass* k = SystemDictionary::ThreadGroup_klass();
1429
1430 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
1431 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1432 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
1433 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
1434 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
1435 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
1436 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
1437 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
1438 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
1439 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
1440 }
1441
1442
1443 void java_lang_Throwable::compute_offsets() {
1444 Klass* k = SystemDictionary::Throwable_klass();
1445 Thread* THREAD = Thread::current();
1446 TempNewSymbol sym = SymbolTable::new_symbol("depth", CATCH);
1447 compute_offset(depth_offset, k, sym, vmSymbols::int_signature());
1448 }
1449
1450 oop java_lang_Throwable::unassigned_stacktrace() {
1451 InstanceKlass* ik = SystemDictionary::Throwable_klass();
1452 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset);
1453 if (UseCompressedOops) {
1454 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
1455 } else {
1456 return oopDesc::load_decode_heap_oop((oop*)addr);
1457 }
1458 }
1459
1460 oop java_lang_Throwable::backtrace(oop throwable) {
1461 return throwable->obj_field_acquire(backtrace_offset);
1462 }
1463
1464
1465 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
1466 throwable->release_obj_field_put(backtrace_offset, value);
1467 }
1468
1469 void java_lang_Throwable::set_depth(oop throwable, int value) {
1470 throwable->int_field_put(depth_offset, value);
1471 }
1472
1473 oop java_lang_Throwable::message(Handle throwable) {
1474 return throwable->obj_field(detailMessage_offset);
1475 }
1476
1477
1478 // Return Symbol for detailed_message or NULL
1479 Symbol* java_lang_Throwable::detail_message(oop throwable) {
1480 PRESERVE_EXCEPTION_MARK; // Keep original exception
1481 oop detailed_message = java_lang_Throwable::message(throwable);
1482 if (detailed_message != NULL) {
1483 return java_lang_String::as_symbol(detailed_message, THREAD);
1484 }
1485 return NULL;
1486 }
1487
1488 void java_lang_Throwable::set_message(oop throwable, oop value) {
1489 throwable->obj_field_put(detailMessage_offset, value);
1490 }
1491
1492
1501
1502 void java_lang_Throwable::print(Handle throwable, outputStream* st) {
1503 ResourceMark rm;
1504 Klass* k = throwable->klass();
1505 assert(k != NULL, "just checking");
1506 st->print("%s", k->external_name());
1507 oop msg = message(throwable);
1508 if (msg != NULL) {
1509 st->print(": %s", java_lang_String::as_utf8_string(msg));
1510 }
1511 }
1512
1513 // After this many redefines, the stack trace is unreliable.
1514 const int MAX_VERSION = USHRT_MAX;
1515
1516 static inline bool version_matches(Method* method, int version) {
1517 assert(version < MAX_VERSION, "version is too big");
1518 return method != NULL && (method->constants()->version() == version);
1519 }
1520
1521
1522 // This class provides a simple wrapper over the internal structure of
1523 // exception backtrace to insulate users of the backtrace from needing
1524 // to know what it looks like.
1525 class BacktraceBuilder: public StackObj {
1526 friend class BacktraceIterator;
1527 private:
1528 Handle _backtrace;
1529 objArrayOop _head;
1530 typeArrayOop _methods;
1531 typeArrayOop _bcis;
1532 objArrayOop _mirrors;
1533 typeArrayOop _cprefs; // needed to insulate method name against redefinition
1534 int _index;
1535 NoSafepointVerifier _nsv;
1536
1537 enum {
1538 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1539 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1540 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1541 trace_cprefs_offset = java_lang_Throwable::trace_cprefs_offset,
1542 trace_next_offset = java_lang_Throwable::trace_next_offset,
1543 trace_size = java_lang_Throwable::trace_size,
1544 trace_chunk_size = java_lang_Throwable::trace_chunk_size
1545 };
1546
1547 // get info out of chunks
1548 static typeArrayOop get_methods(objArrayHandle chunk) {
1549 typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset));
1550 assert(methods != NULL, "method array should be initialized in backtrace");
1551 return methods;
1552 }
1553 static typeArrayOop get_bcis(objArrayHandle chunk) {
1554 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1555 assert(bcis != NULL, "bci array should be initialized in backtrace");
1556 return bcis;
1557 }
1558 static objArrayOop get_mirrors(objArrayHandle chunk) {
1559 objArrayOop mirrors = objArrayOop(chunk->obj_at(trace_mirrors_offset));
1560 assert(mirrors != NULL, "mirror array should be initialized in backtrace");
1561 return mirrors;
1562 }
1563 static typeArrayOop get_cprefs(objArrayHandle chunk) {
1564 typeArrayOop cprefs = typeArrayOop(chunk->obj_at(trace_cprefs_offset));
1565 assert(cprefs != NULL, "cprefs array should be initialized in backtrace");
1566 return cprefs;
1567 }
1568
1569 public:
1570
1571 // constructor for new backtrace
1572 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _cprefs(NULL) {
1573 expand(CHECK);
1574 _backtrace = _head;
1575 _index = 0;
1576 }
1577
1578 BacktraceBuilder(objArrayHandle backtrace) {
1579 _methods = get_methods(backtrace);
1580 _bcis = get_bcis(backtrace);
1581 _mirrors = get_mirrors(backtrace);
1582 _cprefs = get_cprefs(backtrace);
1583 assert(_methods->length() == _bcis->length() &&
1584 _methods->length() == _mirrors->length(),
1585 "method and source information arrays should match");
1586
1587 // head is the preallocated backtrace
1588 _backtrace = _head = backtrace();
1589 _index = 0;
1590 }
1636
1637 if (_index >= trace_chunk_size) {
1638 methodHandle mhandle(THREAD, method);
1639 expand(CHECK);
1640 method = mhandle();
1641 }
1642
1643 _methods->short_at_put(_index, method->orig_method_idnum());
1644 _bcis->int_at_put(_index, Backtrace::merge_bci_and_version(bci, method->constants()->version()));
1645 _cprefs->short_at_put(_index, method->name_index());
1646
1647 // We need to save the mirrors in the backtrace to keep the class
1648 // from being unloaded while we still have this stack trace.
1649 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1650 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1651 _index++;
1652 }
1653
1654 };
1655
1656 struct BacktraceElement : public StackObj {
1657 int _method_id;
1658 int _bci;
1659 int _version;
1660 int _cpref;
1661 Handle _mirror;
1662 BacktraceElement(Handle mirror, int mid, int version, int bci, int cpref) :
1663 _mirror(mirror), _method_id(mid), _version(version), _bci(bci), _cpref(cpref) {}
1664 };
1665
1666 class BacktraceIterator : public StackObj {
1667 int _index;
1668 objArrayHandle _result;
1669 objArrayHandle _mirrors;
1670 typeArrayHandle _methods;
1671 typeArrayHandle _bcis;
1672 typeArrayHandle _cprefs;
1673
1674 void init(objArrayHandle result, Thread* thread) {
1675 // Get method id, bci, version and mirror from chunk
1676 if (_result.not_null()) {
1677 _methods = typeArrayHandle(thread, BacktraceBuilder::get_methods(result));
1678 _bcis = typeArrayHandle(thread, BacktraceBuilder::get_bcis(result));
1679 _mirrors = objArrayHandle(thread, BacktraceBuilder::get_mirrors(result));
1680 _cprefs = typeArrayHandle(thread, BacktraceBuilder::get_cprefs(result));
1681 _index = 0;
1682 }
1683 }
1684 public:
1685 BacktraceIterator(objArrayHandle result, Thread* thread) {
1686 _result = result;
1687 init(result, thread);
1688 assert(_methods->length() == java_lang_Throwable::trace_chunk_size, "lengths don't match");
1689 }
1690
1691 BacktraceElement next(Thread* thread) {
1692 BacktraceElement e (Handle(thread, _mirrors->obj_at(_index)),
1693 _methods->short_at(_index),
1694 Backtrace::version_at(_bcis->int_at(_index)),
1695 Backtrace::bci_at(_bcis->int_at(_index)),
1696 _cprefs->short_at(_index));
1697 _index++;
1698
1699 if (_index >= java_lang_Throwable::trace_chunk_size) {
1700 int next_offset = java_lang_Throwable::trace_next_offset;
1701 _result = objArrayHandle(thread, objArrayOop(_result->obj_at(next_offset)));
1702 init(_result, thread);
1703 }
1704 return e;
1705 }
1706
1707 bool repeat() {
1708 return _result.not_null() && _mirrors->obj_at(_index) != NULL;
1709 }
1710 };
1711
1712
1713 // Print stack trace element to resource allocated buffer
1714 static void print_stack_element_to_stream(outputStream* st, Handle mirror, int method_id,
1715 int version, int bci, int cpref) {
1716 ResourceMark rm;
1717
1718 // Get strings and string lengths
1719 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1720 const char* klass_name = holder->external_name();
1721 int buf_len = (int)strlen(klass_name);
1722
1723 Method* method = holder->method_with_orig_idnum(method_id, version);
1724
1725 // The method can be NULL if the requested class version is gone
1726 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1727 char* method_name = sym->as_C_string();
1728 buf_len += (int)strlen(method_name);
1729
1730 char* source_file_name = NULL;
1731 Symbol* source = Backtrace::get_source_file_name(holder, version);
1732 if (source != NULL) {
1733 source_file_name = source->as_C_string();
1734 buf_len += (int)strlen(source_file_name);
1735 }
1736
1747 if (line_number == -2) {
1748 strcat(buf, "(Native Method)");
1749 } else {
1750 if (source_file_name != NULL && (line_number != -1)) {
1751 // Sourcename and linenumber
1752 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1753 } else if (source_file_name != NULL) {
1754 // Just sourcename
1755 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1756 } else {
1757 // Neither sourcename nor linenumber
1758 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1759 }
1760 nmethod* nm = method->code();
1761 if (WizardMode && nm != NULL) {
1762 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1763 }
1764 }
1765 }
1766
1767 st->print_cr("%s", buf);
1768 }
1769
1770
1771 void java_lang_Throwable::print_stack_element(outputStream *st, const methodHandle& method, int bci) {
1772 Handle mirror = method->method_holder()->java_mirror();
1773 int method_id = method->orig_method_idnum();
1774 int version = method->constants()->version();
1775 int cpref = method->name_index();
1776 print_stack_element_to_stream(st, mirror, method_id, version, bci, cpref);
1777 }
1778
1779 /**
1780 * Print the throwable message and its stack trace plus all causes by walking the
1781 * cause chain. The output looks the same as of Throwable.printStackTrace().
1782 */
1783 void java_lang_Throwable::print_stack_trace(Handle throwable, outputStream* st) {
1784 // First, print the message.
1785 print(throwable, st);
1786 st->cr();
1787
1788 // Now print the stack trace.
1789 Thread* THREAD = Thread::current();
1790 while (throwable.not_null()) {
1791 objArrayHandle result (THREAD, objArrayOop(backtrace(throwable())));
1792 if (result.is_null()) {
1793 st->print_raw_cr("\t<<no stack trace available>>");
1794 return;
1795 }
1796 BacktraceIterator iter(result, THREAD);
1797
1798 while (iter.repeat()) {
1799 BacktraceElement bte = iter.next(THREAD);
1800 print_stack_element_to_stream(st, bte._mirror, bte._method_id, bte._version, bte._bci, bte._cpref);
1801 }
1802 {
1803 // Call getCause() which doesn't necessarily return the _cause field.
1804 EXCEPTION_MARK;
1805 JavaValue cause(T_OBJECT);
1806 JavaCalls::call_virtual(&cause,
1807 throwable,
1808 KlassHandle(THREAD, throwable->klass()),
1809 vmSymbols::getCause_name(),
1810 vmSymbols::void_throwable_signature(),
1811 THREAD);
1812 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1813 if (HAS_PENDING_EXCEPTION) {
1814 CLEAR_PENDING_EXCEPTION;
1815 throwable = Handle();
1816 } else {
1817 throwable = Handle(THREAD, (oop) cause.get_jobject());
1818 if (throwable.not_null()) {
1819 st->print("Caused by: ");
1820 print(throwable, st);
1821 st->cr();
1822 }
1823 }
1835 throwable,
1836 KlassHandle(THREAD, SystemDictionary::Throwable_klass()),
1837 vmSymbols::printStackTrace_name(),
1838 vmSymbols::void_method_signature(),
1839 THREAD);
1840 }
1841
1842 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method, TRAPS) {
1843 if (!StackTraceInThrowable) return;
1844 ResourceMark rm(THREAD);
1845
1846 // Start out by clearing the backtrace for this object, in case the VM
1847 // runs out of memory while allocating the stack trace
1848 set_backtrace(throwable(), NULL);
1849 // Clear lazily constructed Java level stacktrace if refilling occurs
1850 // This is unnecessary in 1.7+ but harmless
1851 clear_stacktrace(throwable());
1852
1853 int max_depth = MaxJavaStackTraceDepth;
1854 JavaThread* thread = (JavaThread*)THREAD;
1855
1856 BacktraceBuilder bt(CHECK);
1857
1858 // If there is no Java frame just return the method that was being called
1859 // with bci 0
1860 if (!thread->has_last_Java_frame()) {
1861 if (max_depth >= 1 && method() != NULL) {
1862 bt.push(method(), 0, CHECK);
1863 log_info(stacktrace)("%s, %d", throwable->klass()->external_name(), 1);
1864 set_depth(throwable(), 1);
1865 set_backtrace(throwable(), bt.backtrace());
1866 }
1867 return;
1868 }
1869
1870 // Instead of using vframe directly, this version of fill_in_stack_trace
1871 // basically handles everything by hand. This significantly improved the
1872 // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows.
1873 // See bug 6333838 for more details.
1874 // The "ASSERT" here is to verify this method generates the exactly same stack
1875 // trace as utilizing vframe.
1876 #ifdef ASSERT
1877 vframeStream st(thread);
1878 methodHandle st_method(THREAD, st.method());
1879 #endif
1880 int total_count = 0;
1881 RegisterMap map(thread, false);
1882 int decode_offset = 0;
1883 nmethod* nm = NULL;
1884 bool skip_fillInStackTrace_check = false;
1952 if (!skip_throwableInit_check) {
1953 assert(skip_fillInStackTrace_check, "logic error in backtrace filtering");
1954
1955 // skip <init> methods of the exception class and superclasses
1956 // This is simlar to classic VM.
1957 if (method->name() == vmSymbols::object_initializer_name() &&
1958 throwable->is_a(method->method_holder())) {
1959 continue;
1960 } else {
1961 // there are none or we've seen them all - either way stop checking
1962 skip_throwableInit_check = true;
1963 }
1964 }
1965 if (method->is_hidden()) {
1966 if (skip_hidden) continue;
1967 }
1968 bt.push(method, bci, CHECK);
1969 total_count++;
1970 }
1971
1972 log_info(stacktrace)("%s, %d", throwable->klass()->external_name(), total_count);
1973
1974 // Put completed stack trace into throwable object
1975 set_backtrace(throwable(), bt.backtrace());
1976 set_depth(throwable(), total_count);
1977 }
1978
1979 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method) {
1980 // No-op if stack trace is disabled
1981 if (!StackTraceInThrowable) {
1982 return;
1983 }
1984
1985 // Disable stack traces for some preallocated out of memory errors
1986 if (!Universe::should_fill_in_stack_trace(throwable)) {
1987 return;
1988 }
1989
1990 PRESERVE_EXCEPTION_MARK;
1991
1992 JavaThread* thread = JavaThread::active();
1993 fill_in_stack_trace(throwable, method, thread);
1994 // ignore exceptions thrown during stack trace filling
1995 CLEAR_PENDING_EXCEPTION;
1996 }
2010
2011 // No-op if stack trace is disabled
2012 if (!StackTraceInThrowable) return;
2013
2014 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check");
2015
2016 JavaThread* THREAD = JavaThread::current();
2017
2018 objArrayHandle backtrace (THREAD, (objArrayOop)java_lang_Throwable::backtrace(throwable()));
2019 assert(backtrace.not_null(), "backtrace should have been preallocated");
2020
2021 ResourceMark rm(THREAD);
2022 vframeStream st(THREAD);
2023
2024 BacktraceBuilder bt(backtrace);
2025
2026 // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init
2027 // methods as preallocated errors aren't created by "java" code.
2028
2029 // fill in as much stack trace as possible
2030 int chunk_count = 0;
2031 for (;!st.at_end(); st.next()) {
2032 bt.push(st.method(), st.bci(), CHECK);
2033 chunk_count++;
2034
2035 // Bail-out for deep stacks
2036 if (chunk_count >= trace_chunk_size) break;
2037 }
2038 set_depth(throwable(), chunk_count);
2039
2040 {
2041 ResourceMark rm;
2042 log_info(stacktrace)("%s, %d", throwable->klass()->external_name(), chunk_count);
2043 }
2044
2045 // We support the Throwable immutability protocol defined for Java 7.
2046 java_lang_Throwable::set_stacktrace(throwable(), java_lang_Throwable::unassigned_stacktrace());
2047 assert(java_lang_Throwable::unassigned_stacktrace() != NULL, "not initialized");
2048 }
2049
2050 void java_lang_Throwable::get_stack_trace_elements(Handle throwable,
2051 objArrayHandle stack_trace_array_h, TRAPS) {
2052 if (throwable == NULL) {
2053 THROW(vmSymbols::java_lang_NullPointerException());
2054 }
2055
2056 objArrayHandle result(THREAD, objArrayOop(backtrace(throwable())));
2057 BacktraceIterator iter(result, THREAD);
2058
2059 int index = 0;
2060 while (iter.repeat()) {
2061 BacktraceElement bte = iter.next(THREAD);
2062 Handle stack_trace_element(THREAD, stack_trace_array_h->obj_at(index++));
2063
2064 if (stack_trace_element.is_null()) {
2065 THROW(vmSymbols::java_lang_IndexOutOfBoundsException());
2066 }
2067
2068 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(bte._mirror()));
2069 methodHandle method (THREAD, holder->method_with_orig_idnum(bte._method_id, bte._version));
2070
2071 java_lang_StackTraceElement::fill_in(stack_trace_element, holder,
2072 method,
2073 bte._version,
2074 bte._bci,
2075 bte._cpref, CHECK);
2076 }
2077 }
2078
2079 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
2080 // Allocate java.lang.StackTraceElement instance
2081 Klass* k = SystemDictionary::StackTraceElement_klass();
2082 assert(k != NULL, "must be loaded in 1.4+");
2083 instanceKlassHandle ik (THREAD, k);
2084 if (ik->should_be_initialized()) {
2085 ik->initialize(CHECK_0);
2086 }
2087
2088 Handle element = ik->allocate_instance_handle(CHECK_0);
2089
2090 int cpref = method->name_index();
2091 int version = method->constants()->version();
2092 fill_in(element, method->method_holder(), method, version, bci, cpref, CHECK_0);
2093 return element();
2094 }
2095
2096 void java_lang_StackTraceElement::fill_in(Handle element,
2097 InstanceKlass* holder, const methodHandle& method,
2098 int version, int bci, int cpref, TRAPS) {
2099 assert(element->is_a(SystemDictionary::StackTraceElement_klass()), "sanity check");
2100
2101 // Fill in class name
2102 ResourceMark rm(THREAD);
2103 const char* str = holder->external_name();
2104 oop classname = StringTable::intern((char*) str, CHECK);
2105 java_lang_StackTraceElement::set_declaringClass(element(), classname);
2106
2107 // The method can be NULL if the requested class version is gone
2108 Symbol* sym = !method.is_null() ? method->name() : holder->constants()->symbol_at(cpref);
2109
2110 // Fill in method name
2111 oop methodname = StringTable::intern(sym, CHECK);
2112 java_lang_StackTraceElement::set_methodName(element(), methodname);
2113
2114 if (!version_matches(method(), version)) {
2115 // The method was redefined, accurate line number information isn't available
2116 java_lang_StackTraceElement::set_fileName(element(), NULL);
2117 java_lang_StackTraceElement::set_lineNumber(element(), -1);
2118 } else {
2119 // Fill in source file name and line number.
2120 Symbol* source = Backtrace::get_source_file_name(holder, version);
2121 if (ShowHiddenFrames && source == NULL)
2122 source = vmSymbols::unknown_class_name();
2123 oop filename = StringTable::intern(source, CHECK);
2124 java_lang_StackTraceElement::set_fileName(element(), filename);
2125
2126 int line_number = Backtrace::get_line_number(method, bci);
2127 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
2128 }
2129 }
2130
2131 Method* java_lang_StackFrameInfo::get_method(Handle stackFrame, InstanceKlass* holder, TRAPS) {
2132 if (MemberNameInStackFrame) {
2133 Handle mname(THREAD, stackFrame->obj_field(_memberName_offset));
2134 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mname());
2135 // we should expand MemberName::name when Throwable uses StackTrace
2136 // MethodHandles::expand_MemberName(mname, MethodHandles::_suppress_defc|MethodHandles::_suppress_type, CHECK_NULL);
2137 return method;
2138 } else {
2139 short mid = stackFrame->short_field(_mid_offset);
2140 short version = stackFrame->short_field(_version_offset);
2141 return holder->method_with_orig_idnum(mid, version);
2142 }
2143 }
2144
2145 Symbol* java_lang_StackFrameInfo::get_file_name(Handle stackFrame, InstanceKlass* holder) {
2146 if (MemberNameInStackFrame) {
2147 return holder->source_file_name();
2148 } else {
3469 address addr = ik->static_field_addr(static_security_offset);
3470 if (UseCompressedOops) {
3471 return oopDesc::load_decode_heap_oop((narrowOop *)addr) != NULL;
3472 } else {
3473 return oopDesc::load_decode_heap_oop((oop*)addr) != NULL;
3474 }
3475 }
3476
3477 int java_lang_Class::_klass_offset;
3478 int java_lang_Class::_array_klass_offset;
3479 int java_lang_Class::_oop_size_offset;
3480 int java_lang_Class::_static_oop_field_count_offset;
3481 int java_lang_Class::_class_loader_offset;
3482 int java_lang_Class::_protection_domain_offset;
3483 int java_lang_Class::_component_mirror_offset;
3484 int java_lang_Class::_init_lock_offset;
3485 int java_lang_Class::_signers_offset;
3486 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
3487 int java_lang_Throwable::backtrace_offset;
3488 int java_lang_Throwable::detailMessage_offset;
3489 int java_lang_Throwable::stackTrace_offset;
3490 int java_lang_Throwable::depth_offset;
3491 int java_lang_Throwable::static_unassigned_stacktrace_offset;
3492 int java_lang_reflect_AccessibleObject::override_offset;
3493 int java_lang_reflect_Method::clazz_offset;
3494 int java_lang_reflect_Method::name_offset;
3495 int java_lang_reflect_Method::returnType_offset;
3496 int java_lang_reflect_Method::parameterTypes_offset;
3497 int java_lang_reflect_Method::exceptionTypes_offset;
3498 int java_lang_reflect_Method::slot_offset;
3499 int java_lang_reflect_Method::modifiers_offset;
3500 int java_lang_reflect_Method::signature_offset;
3501 int java_lang_reflect_Method::annotations_offset;
3502 int java_lang_reflect_Method::parameter_annotations_offset;
3503 int java_lang_reflect_Method::annotation_default_offset;
3504 int java_lang_reflect_Method::type_annotations_offset;
3505 int java_lang_reflect_Constructor::clazz_offset;
3506 int java_lang_reflect_Constructor::parameterTypes_offset;
3507 int java_lang_reflect_Constructor::exceptionTypes_offset;
3508 int java_lang_reflect_Constructor::slot_offset;
3509 int java_lang_reflect_Constructor::modifiers_offset;
3510 int java_lang_reflect_Constructor::signature_offset;
3671 Klass* k = SystemDictionary::abstract_ownable_synchronizer_klass();
3672 compute_offset(_owner_offset, k,
3673 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
3674 }
3675
3676 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
3677 assert(_owner_offset != 0, "Must be initialized");
3678 return obj->obj_field(_owner_offset);
3679 }
3680
3681 // Compute hard-coded offsets
3682 // Invoked before SystemDictionary::initialize, so pre-loaded classes
3683 // are not available to determine the offset_of_static_fields.
3684 void JavaClasses::compute_hard_coded_offsets() {
3685 const int x = heapOopSize;
3686 const int header = instanceOopDesc::base_offset_in_bytes();
3687
3688 // Throwable Class
3689 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
3690 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
3691 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
3692 java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset * x;
3693
3694 // java_lang_boxing_object
3695 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
3696 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
3697
3698 // java_lang_ref_Reference:
3699 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
3700 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
3701 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
3702 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
3703 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
3704 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
3705 // Artificial fields for java_lang_ref_Reference
3706 // The first field is for the discovered field added in 1.4
3707 java_lang_ref_Reference::number_of_fake_oop_fields = 1;
3708
3709 // java_lang_ref_SoftReference Class
3710 java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong);
3721 java_lang_System::static_security_offset = java_lang_System::hc_static_security_offset * x;
3722
3723 // java_lang_StackTraceElement
3724 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header;
3725 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
3726 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header;
3727 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
3728 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
3729 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
3730 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
3731 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
3732 java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header;
3733
3734 }
3735
3736
3737 // Compute non-hard-coded field offsets of all the classes in this file
3738 void JavaClasses::compute_offsets() {
3739 // java_lang_Class::compute_offsets was called earlier in bootstrap
3740 java_lang_ClassLoader::compute_offsets();
3741 java_lang_Throwable::compute_offsets();
3742 java_lang_Thread::compute_offsets();
3743 java_lang_ThreadGroup::compute_offsets();
3744 java_lang_invoke_MethodHandle::compute_offsets();
3745 java_lang_invoke_DirectMethodHandle::compute_offsets();
3746 java_lang_invoke_MemberName::compute_offsets();
3747 java_lang_invoke_LambdaForm::compute_offsets();
3748 java_lang_invoke_MethodType::compute_offsets();
3749 java_lang_invoke_CallSite::compute_offsets();
3750 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets();
3751 java_security_AccessControlContext::compute_offsets();
3752 // Initialize reflection classes. The layouts of these classes
3753 // changed with the new reflection implementation in JDK 1.4, and
3754 // since the Universe doesn't know what JDK version it is until this
3755 // point we defer computation of these offsets until now.
3756 java_lang_reflect_AccessibleObject::compute_offsets();
3757 java_lang_reflect_Method::compute_offsets();
3758 java_lang_reflect_Constructor::compute_offsets();
3759 java_lang_reflect_Field::compute_offsets();
3760 java_nio_Buffer::compute_offsets();
3761 sun_reflect_ConstantPool::compute_offsets();
3875 // java.lang.String
3876
3877 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[B");
3878 if (java_lang_String::has_hash_field()) {
3879 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
3880 }
3881 if (java_lang_String::has_coder_field()) {
3882 CHECK_OFFSET("java/lang/String", java_lang_String, coder, "B");
3883 }
3884
3885 // java.lang.Class
3886
3887 // Fake fields
3888 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
3889 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
3890
3891 // java.lang.Throwable
3892
3893 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
3894 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
3895 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
3896 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, depth, "I");
3897
3898 // Boxed primitive objects (java_lang_boxing_object)
3899
3900 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
3901 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
3902 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
3903 CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D");
3904 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B");
3905 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S");
3906 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I");
3907 CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J");
3908
3909 // java.lang.ClassLoader
3910
3911 CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;");
3912
3913 // java.lang.System
3914
3915 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;");
3916 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;");
|