7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/altHashing.hpp"
27 #include "classfile/javaClasses.inline.hpp"
28 #include "classfile/stringTable.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "code/debugInfo.hpp"
31 #include "code/pcDesc.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "memory/oopFactory.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "memory/universe.inline.hpp"
36 #include "oops/fieldStreams.hpp"
37 #include "oops/instanceKlass.hpp"
38 #include "oops/instanceMirrorKlass.hpp"
39 #include "oops/klass.hpp"
40 #include "oops/method.hpp"
41 #include "oops/objArrayOop.inline.hpp"
42 #include "oops/oop.inline.hpp"
43 #include "oops/symbol.hpp"
44 #include "oops/typeArrayOop.hpp"
45 #include "prims/jvmtiRedefineClassesTrace.hpp"
46 #include "runtime/fieldDescriptor.hpp"
1313 }
1314
1315 // After this many redefines, the stack trace is unreliable.
1316 const int MAX_VERSION = USHRT_MAX;
1317
1318 // Helper backtrace functions to store bci|version together.
1319 static inline int merge_bci_and_version(int bci, int version) {
1320 // only store u2 for version, checking for overflow.
1321 if (version > USHRT_MAX || version < 0) version = MAX_VERSION;
1322 assert((jushort)bci == bci, "bci should be short");
1323 return build_int_from_shorts(version, bci);
1324 }
1325
1326 static inline int bci_at(unsigned int merged) {
1327 return extract_high_short_from_int(merged);
1328 }
1329 static inline int version_at(unsigned int merged) {
1330 return extract_low_short_from_int(merged);
1331 }
1332
1333 static inline bool version_matches(Method* method, int version) {
1334 assert(version < MAX_VERSION, "version is too big");
1335 return method != NULL && (method->constants()->version() == version);
1336 }
1337
1338 static inline int get_line_number(Method* method, int bci) {
1339 int line_number = 0;
1340 if (method->is_native()) {
1341 // Negative value different from -1 below, enabling Java code in
1342 // class java.lang.StackTraceElement to distinguish "native" from
1343 // "no LineNumberTable". JDK tests for -2.
1344 line_number = -2;
1345 } else {
1346 // Returns -1 if no LineNumberTable, and otherwise actual line number
1347 line_number = method->line_number_from_bci(bci);
1348 if (line_number == -1 && ShowHiddenFrames) {
1349 line_number = bci + 1000000;
1350 }
1351 }
1352 return line_number;
1353 }
1354
1355 // This class provides a simple wrapper over the internal structure of
1356 // exception backtrace to insulate users of the backtrace from needing
1357 // to know what it looks like.
1358 class BacktraceBuilder: public StackObj {
1359 private:
1360 Handle _backtrace;
1361 objArrayOop _head;
1362 typeArrayOop _methods;
1363 typeArrayOop _bcis;
1364 objArrayOop _mirrors;
1365 typeArrayOop _cprefs; // needed to insulate method name against redefinition
1366 int _index;
1367 No_Safepoint_Verifier _nsv;
1368
1369 public:
1370
1371 enum {
1372 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1373 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1374 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1375 trace_cprefs_offset = java_lang_Throwable::trace_cprefs_offset,
1376 trace_next_offset = java_lang_Throwable::trace_next_offset,
1377 trace_size = java_lang_Throwable::trace_size,
1378 trace_chunk_size = java_lang_Throwable::trace_chunk_size
1379 };
1380
1381 // get info out of chunks
1382 static typeArrayOop get_methods(objArrayHandle chunk) {
1383 typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset));
1384 assert(methods != NULL, "method array should be initialized in backtrace");
1385 return methods;
1386 }
1387 static typeArrayOop get_bcis(objArrayHandle chunk) {
1388 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1389 assert(bcis != NULL, "bci array should be initialized in backtrace");
1390 return bcis;
1391 }
1392 static objArrayOop get_mirrors(objArrayHandle chunk) {
1393 objArrayOop mirrors = objArrayOop(chunk->obj_at(trace_mirrors_offset));
1394 assert(mirrors != NULL, "mirror array should be initialized in backtrace");
1395 return mirrors;
1396 }
1397 static typeArrayOop get_cprefs(objArrayHandle chunk) {
1398 typeArrayOop cprefs = typeArrayOop(chunk->obj_at(trace_cprefs_offset));
1399 assert(cprefs != NULL, "cprefs array should be initialized in backtrace");
1400 return cprefs;
1401 }
1402
1403 // constructor for new backtrace
1404 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _cprefs(NULL) {
1405 expand(CHECK);
1406 _backtrace = _head;
1407 _index = 0;
1408 }
1409
1410 BacktraceBuilder(objArrayHandle backtrace) {
1411 _methods = get_methods(backtrace);
1412 _bcis = get_bcis(backtrace);
1413 _mirrors = get_mirrors(backtrace);
1414 _cprefs = get_cprefs(backtrace);
1415 assert(_methods->length() == _bcis->length() &&
1416 _methods->length() == _mirrors->length(),
1417 "method and source information arrays should match");
1418
1419 // head is the preallocated backtrace
1420 _backtrace = _head = backtrace();
1421 _index = 0;
1422 }
1423
1424 void expand(TRAPS) {
1425 objArrayHandle old_head(THREAD, _head);
1426 Pause_No_Safepoint_Verifier pnsv(&_nsv);
1427
1428 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);
1429 objArrayHandle new_head(THREAD, head);
1430
1431 typeArrayOop methods = oopFactory::new_shortArray(trace_chunk_size, CHECK);
1432 typeArrayHandle new_methods(THREAD, methods);
1433
1434 typeArrayOop bcis = oopFactory::new_intArray(trace_chunk_size, CHECK);
1435 typeArrayHandle new_bcis(THREAD, bcis);
1436
1437 objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK);
1438 objArrayHandle new_mirrors(THREAD, mirrors);
1439
1440 typeArrayOop cprefs = oopFactory::new_shortArray(trace_chunk_size, CHECK);
1441 typeArrayHandle new_cprefs(THREAD, cprefs);
1442
1443 if (!old_head.is_null()) {
1444 old_head->obj_at_put(trace_next_offset, new_head());
1445 }
1446 new_head->obj_at_put(trace_methods_offset, new_methods());
1447 new_head->obj_at_put(trace_bcis_offset, new_bcis());
1448 new_head->obj_at_put(trace_mirrors_offset, new_mirrors());
1449 new_head->obj_at_put(trace_cprefs_offset, new_cprefs());
1450
1451 _head = new_head();
1452 _methods = new_methods();
1453 _bcis = new_bcis();
1454 _mirrors = new_mirrors();
1455 _cprefs = new_cprefs();
1456 _index = 0;
1457 }
1458
1459 oop backtrace() {
1460 return _backtrace();
1461 }
1462
1463 inline void push(Method* method, int bci, TRAPS) {
1464 // Smear the -1 bci to 0 since the array only holds unsigned
1465 // shorts. The later line number lookup would just smear the -1
1466 // to a 0 even if it could be recorded.
1467 if (bci == SynchronizationEntryBCI) bci = 0;
1468
1469 if (_index >= trace_chunk_size) {
1470 methodHandle mhandle(THREAD, method);
1471 expand(CHECK);
1472 method = mhandle();
1473 }
1474
1475 _methods->short_at_put(_index, method->orig_method_idnum());
1476 _bcis->int_at_put(_index, merge_bci_and_version(bci, method->constants()->version()));
1477 _cprefs->short_at_put(_index, method->name_index());
1478
1479 // We need to save the mirrors in the backtrace to keep the class
1480 // from being unloaded while we still have this stack trace.
1481 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1482 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1483 _index++;
1484 }
1485
1486 };
1487
1488 Symbol* get_source_file_name(InstanceKlass* holder, int version) {
1489 // Find the specific ik version that contains this source_file_name_index
1490 // via the previous versions list, but use the current version's
1491 // constant pool to look it up. The previous version's index has been
1492 // merged for the current constant pool.
1493 InstanceKlass* ik = holder->get_klass_version(version);
1494 // This version has been cleaned up.
1495 if (ik == NULL) return NULL;
1496 int source_file_name_index = ik->source_file_name_index();
1497 return (source_file_name_index == 0) ?
1498 (Symbol*)NULL : holder->constants()->symbol_at(source_file_name_index);
1499 }
1500
1501 // Print stack trace element to resource allocated buffer
1502 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
1503 int method_id, int version, int bci, int cpref) {
1504
1505 // Get strings and string lengths
1506 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1507 const char* klass_name = holder->external_name();
1508 int buf_len = (int)strlen(klass_name);
1509
1510 Method* method = holder->method_with_orig_idnum(method_id, version);
1511
1512 // The method can be NULL if the requested class version is gone
1513 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1514 char* method_name = sym->as_C_string();
1515 buf_len += (int)strlen(method_name);
1516
1517 char* source_file_name = NULL;
1518 Symbol* source = get_source_file_name(holder, version);
1519 if (source != NULL) {
1520 source_file_name = source->as_C_string();
1521 buf_len += (int)strlen(source_file_name);
1522 }
1523
1524 // Allocate temporary buffer with extra space for formatting and line number
1525 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);
1526
1527 // Print stack trace line in buffer
1528 sprintf(buf, "\tat %s.%s", klass_name, method_name);
1529
1530 if (!version_matches(method, version)) {
1531 strcat(buf, "(Redefined)");
1532 } else {
1533 int line_number = get_line_number(method, bci);
1534 if (line_number == -2) {
1535 strcat(buf, "(Native Method)");
1536 } else {
1537 if (source_file_name != NULL && (line_number != -1)) {
1538 // Sourcename and linenumber
1539 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1540 } else if (source_file_name != NULL) {
1541 // Just sourcename
1542 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1543 } else {
1544 // Neither sourcename nor linenumber
1545 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1546 }
1547 nmethod* nm = method->code();
1548 if (WizardMode && nm != NULL) {
1549 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1550 }
1551 }
1552 }
1553
1554 return buf;
1555 }
1556
1557 void java_lang_Throwable::print_stack_element(outputStream *st, Handle mirror,
1558 int method_id, int version, int bci, int cpref) {
1559 ResourceMark rm;
1560 char* buf = print_stack_element_to_buffer(mirror, method_id, version, bci, cpref);
1561 st->print_cr("%s", buf);
1562 }
1563
1564 void java_lang_Throwable::print_stack_element(outputStream *st, const methodHandle& method, int bci) {
1565 Handle mirror = method->method_holder()->java_mirror();
1566 int method_id = method->orig_method_idnum();
1567 int version = method->constants()->version();
1568 int cpref = method->name_index();
1569 print_stack_element(st, mirror, method_id, version, bci, cpref);
1570 }
1571
1572 const char* java_lang_Throwable::no_stack_trace_message() {
1573 return "\t<<no stack trace available>>";
1574 }
1575
1576
1577 // Currently used only for exceptions occurring during startup
1578 void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) {
1579 Thread *THREAD = Thread::current();
1580 Handle h_throwable(THREAD, throwable);
1581 while (h_throwable.not_null()) {
1582 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
1583 if (result.is_null()) {
1584 st->print_raw_cr(no_stack_trace_message());
1585 return;
1586 }
1587
1588 while (result.not_null()) {
1589
1590 // Get method id, bci, version and mirror from chunk
1591 typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
1592 typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
1593 objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
1594 typeArrayHandle cprefs (THREAD, BacktraceBuilder::get_cprefs(result));
1595
1596 int length = methods()->length();
1597 for (int index = 0; index < length; index++) {
1598 Handle mirror(THREAD, mirrors->obj_at(index));
1599 // NULL mirror means end of stack trace
1600 if (mirror.is_null()) goto handle_cause;
1601 int method = methods->short_at(index);
1602 int version = version_at(bcis->int_at(index));
1603 int bci = bci_at(bcis->int_at(index));
1604 int cpref = cprefs->short_at(index);
1605 print_stack_element(st, mirror, method, version, bci, cpref);
1606 }
1607 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
1608 }
1609 handle_cause:
1610 {
1611 EXCEPTION_MARK;
1612 JavaValue cause(T_OBJECT);
1613 JavaCalls::call_virtual(&cause,
1614 h_throwable,
1615 KlassHandle(THREAD, h_throwable->klass()),
1616 vmSymbols::getCause_name(),
1617 vmSymbols::void_throwable_signature(),
1618 THREAD);
1619 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1620 if (HAS_PENDING_EXCEPTION) {
1621 CLEAR_PENDING_EXCEPTION;
1622 h_throwable = Handle();
1623 } else {
1624 h_throwable = Handle(THREAD, (oop) cause.get_jobject());
1625 if (h_throwable.not_null()) {
1628 st->cr();
1629 }
1630 }
1631 }
1632 }
1633 }
1634
1635 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method, TRAPS) {
1636 if (!StackTraceInThrowable) return;
1637 ResourceMark rm(THREAD);
1638
1639 // Start out by clearing the backtrace for this object, in case the VM
1640 // runs out of memory while allocating the stack trace
1641 set_backtrace(throwable(), NULL);
1642 // Clear lazily constructed Java level stacktrace if refilling occurs
1643 // This is unnecessary in 1.7+ but harmless
1644 clear_stacktrace(throwable());
1645
1646 int max_depth = MaxJavaStackTraceDepth;
1647 JavaThread* thread = (JavaThread*)THREAD;
1648 BacktraceBuilder bt(CHECK);
1649
1650 // If there is no Java frame just return the method that was being called
1651 // with bci 0
1652 if (!thread->has_last_Java_frame()) {
1653 if (max_depth >= 1 && method() != NULL) {
1654 bt.push(method(), 0, CHECK);
1655 set_backtrace(throwable(), bt.backtrace());
1656 }
1657 return;
1658 }
1659
1660 // Instead of using vframe directly, this version of fill_in_stack_trace
1661 // basically handles everything by hand. This significantly improved the
1662 // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows.
1663 // See bug 6333838 for more details.
1664 // The "ASSERT" here is to verify this method generates the exactly same stack
1665 // trace as utilizing vframe.
1666 #ifdef ASSERT
1667 vframeStream st(thread);
1668 methodHandle st_method(THREAD, st.method());
1770 }
1771
1772 // Disable stack traces for some preallocated out of memory errors
1773 if (!Universe::should_fill_in_stack_trace(throwable)) {
1774 return;
1775 }
1776
1777 PRESERVE_EXCEPTION_MARK;
1778
1779 JavaThread* thread = JavaThread::active();
1780 fill_in_stack_trace(throwable, method, thread);
1781 // ignore exceptions thrown during stack trace filling
1782 CLEAR_PENDING_EXCEPTION;
1783 }
1784
1785 void java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) {
1786 // Allocate stack trace - backtrace is created but not filled in
1787
1788 // No-op if stack trace is disabled
1789 if (!StackTraceInThrowable) return;
1790 BacktraceBuilder bt(CHECK); // creates a backtrace
1791 set_backtrace(throwable(), bt.backtrace());
1792 }
1793
1794
1795 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) {
1796 // Fill in stack trace into preallocated backtrace (no GC)
1797
1798 // No-op if stack trace is disabled
1799 if (!StackTraceInThrowable) return;
1800
1801 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check");
1802
1803 JavaThread* THREAD = JavaThread::current();
1804
1805 objArrayHandle backtrace (THREAD, (objArrayOop)java_lang_Throwable::backtrace(throwable()));
1806 assert(backtrace.not_null(), "backtrace should have been preallocated");
1807
1808 ResourceMark rm(THREAD);
1809 vframeStream st(THREAD);
1810
1861
1862
1863 oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) {
1864 if (throwable == NULL) {
1865 THROW_0(vmSymbols::java_lang_NullPointerException());
1866 }
1867 if (index < 0) {
1868 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1869 }
1870 // Compute how many chunks to skip and index into actual chunk
1871 objArrayOop chunk = objArrayOop(backtrace(throwable));
1872 int skip_chunks = index / trace_chunk_size;
1873 int chunk_index = index % trace_chunk_size;
1874 while (chunk != NULL && skip_chunks > 0) {
1875 chunk = objArrayOop(chunk->obj_at(trace_next_offset));
1876 skip_chunks--;
1877 }
1878 if (chunk == NULL) {
1879 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1880 }
1881 // Get method id, bci, version, mirror and cpref from chunk
1882 typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
1883 typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
1884 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
1885 typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
1886
1887 assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
1888
1889 int method = methods->short_at(chunk_index);
1890 int version = version_at(bcis->int_at(chunk_index));
1891 int bci = bci_at(bcis->int_at(chunk_index));
1892 int cpref = cprefs->short_at(chunk_index);
1893 Handle mirror(THREAD, mirrors->obj_at(chunk_index));
1894
1895 // Chunk can be partial full
1896 if (mirror.is_null()) {
1897 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1898 }
1899 oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, cpref, CHECK_0);
1900 return element;
1901 }
1902
1903 oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
1904 int version, int bci, int cpref, TRAPS) {
1905 // Allocate java.lang.StackTraceElement instance
1906 Klass* k = SystemDictionary::StackTraceElement_klass();
1907 assert(k != NULL, "must be loaded in 1.4+");
1908 instanceKlassHandle ik (THREAD, k);
1909 if (ik->should_be_initialized()) {
1910 ik->initialize(CHECK_0);
1911 }
1912
1913 Handle element = ik->allocate_instance_handle(CHECK_0);
1914 // Fill in class name
1915 ResourceMark rm(THREAD);
1916 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1917 const char* str = holder->external_name();
1918 oop classname = StringTable::intern((char*) str, CHECK_0);
1919 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1920
1921 Method* method = holder->method_with_orig_idnum(method_id, version);
1922
1923 // The method can be NULL if the requested class version is gone
1924 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1925
1926 // Fill in method name
1927 oop methodname = StringTable::intern(sym, CHECK_0);
1928 java_lang_StackTraceElement::set_methodName(element(), methodname);
1929
1930 if (!version_matches(method, version)) {
1931 // The method was redefined, accurate line number information isn't available
1932 java_lang_StackTraceElement::set_fileName(element(), NULL);
1933 java_lang_StackTraceElement::set_lineNumber(element(), -1);
1934 } else {
1935 // Fill in source file name and line number.
1936 Symbol* source = get_source_file_name(holder, version);
1937 if (ShowHiddenFrames && source == NULL)
1938 source = vmSymbols::unknown_class_name();
1939 oop filename = StringTable::intern(source, CHECK_0);
1940 java_lang_StackTraceElement::set_fileName(element(), filename);
1941
1942 int line_number = get_line_number(method, bci);
1943 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1944 }
1945 return element();
1946 }
1947
1948 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
1949 Handle mirror (THREAD, method->method_holder()->java_mirror());
1950 int method_id = method->orig_method_idnum();
1951 int cpref = method->name_index();
1952 return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
1953 }
1954
1955 void java_lang_reflect_AccessibleObject::compute_offsets() {
1956 Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
1957 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
1958 }
1959
1960 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
1961 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1962 return (jboolean) reflect->bool_field(override_offset);
1963 }
1964
1965 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
1966 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1967 reflect->bool_field_put(override_offset, (int) value);
1968 }
1969
1970 void java_lang_reflect_Method::compute_offsets() {
1971 Klass* k = SystemDictionary::reflect_Method_klass();
1972 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
|
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/altHashing.hpp"
27 #include "classfile/backtrace.hpp"
28 #include "classfile/javaClasses.inline.hpp"
29 #include "classfile/stringTable.hpp"
30 #include "classfile/vmSymbols.hpp"
31 #include "code/debugInfo.hpp"
32 #include "code/pcDesc.hpp"
33 #include "interpreter/interpreter.hpp"
34 #include "memory/oopFactory.hpp"
35 #include "memory/resourceArea.hpp"
36 #include "memory/universe.inline.hpp"
37 #include "oops/fieldStreams.hpp"
38 #include "oops/instanceKlass.hpp"
39 #include "oops/instanceMirrorKlass.hpp"
40 #include "oops/klass.hpp"
41 #include "oops/method.hpp"
42 #include "oops/objArrayOop.inline.hpp"
43 #include "oops/oop.inline.hpp"
44 #include "oops/symbol.hpp"
45 #include "oops/typeArrayOop.hpp"
46 #include "prims/jvmtiRedefineClassesTrace.hpp"
47 #include "runtime/fieldDescriptor.hpp"
1314 }
1315
1316 // After this many redefines, the stack trace is unreliable.
1317 const int MAX_VERSION = USHRT_MAX;
1318
1319 // Helper backtrace functions to store bci|version together.
1320 static inline int merge_bci_and_version(int bci, int version) {
1321 // only store u2 for version, checking for overflow.
1322 if (version > USHRT_MAX || version < 0) version = MAX_VERSION;
1323 assert((jushort)bci == bci, "bci should be short");
1324 return build_int_from_shorts(version, bci);
1325 }
1326
1327 static inline int bci_at(unsigned int merged) {
1328 return extract_high_short_from_int(merged);
1329 }
1330 static inline int version_at(unsigned int merged) {
1331 return extract_low_short_from_int(merged);
1332 }
1333
1334 static inline int get_line_number(const methodHandle& method, int bci) {
1335 int line_number = 0;
1336 if (method->is_native()) {
1337 // Negative value different from -1 below, enabling Java code in
1338 // class java.lang.StackTraceElement to distinguish "native" from
1339 // "no LineNumberTable". JDK tests for -2.
1340 line_number = -2;
1341 } else {
1342 // Returns -1 if no LineNumberTable, and otherwise actual line number
1343 line_number = method->line_number_from_bci(bci);
1344 if (line_number == -1 && ShowHiddenFrames) {
1345 line_number = bci + 1000000;
1346 }
1347 }
1348 return line_number;
1349 }
1350
1351 // Mark all of the methods in this backtrace as on the stack during full GC
1352 // so that they aren't deallocated if any of these methods are redefined.
1353 void java_lang_Throwable::mark_on_stack(oop throwable) {
1354 objArrayOop result = objArrayOop(backtrace(throwable));
1355
1356 while (result != NULL) {
1357 typeArrayOop methods = typeArrayOop(result->obj_at(trace_methods_offset));
1358
1359 if (methods == NULL) {
1360 return;
1361 }
1362
1363 int length = methods->length();
1364 for (int index = 0; index < length; index++) {
1365 Method* method = ((Method*)methods->metadata_at(index));
1366 if (method == NULL) return;
1367 method->set_on_stack(true);
1368 }
1369 result = objArrayOop(result->obj_at(trace_next_offset));
1370 }
1371 }
1372
1373 // This class provides a simple wrapper over the internal structure of
1374 // exception backtrace to insulate users of the backtrace from needing
1375 // to know what it looks like.
1376 class BacktraceBuilder: public StackObj {
1377 private:
1378 Handle _backtrace;
1379 objArrayOop _head;
1380 typeArrayOop _methods;
1381 typeArrayOop _bcis;
1382 objArrayOop _mirrors;
1383 int _index;
1384 No_Safepoint_Verifier _nsv;
1385
1386 void add_backtrace(Handle throwable) {
1387 Pause_No_Safepoint_Verifier pnsv(&_nsv);
1388 // RedefineClasses support
1389 // Save this backtrace object to find methods used in Java heap
1390 BacktraceList::add(throwable());
1391 }
1392
1393 void expand(TRAPS) {
1394 objArrayHandle old_head(THREAD, _head);
1395 Pause_No_Safepoint_Verifier pnsv(&_nsv);
1396
1397 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);
1398 objArrayHandle new_head(THREAD, head);
1399
1400 typeArrayOop methods = oopFactory::new_metadataArray(trace_chunk_size, CHECK);
1401 typeArrayHandle new_methods(THREAD, methods);
1402
1403 typeArrayOop bcis = oopFactory::new_intArray(trace_chunk_size, CHECK);
1404 typeArrayHandle new_bcis(THREAD, bcis);
1405
1406 objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK);
1407 objArrayHandle new_mirrors(THREAD, mirrors);
1408
1409 if (!old_head.is_null()) {
1410 old_head->obj_at_put(trace_next_offset, new_head());
1411 }
1412 new_head->obj_at_put(trace_methods_offset, new_methods());
1413 new_head->obj_at_put(trace_bcis_offset, new_bcis());
1414 new_head->obj_at_put(trace_mirrors_offset, new_mirrors());
1415
1416 _head = new_head();
1417 _methods = new_methods();
1418 _bcis = new_bcis();
1419 _mirrors = new_mirrors();
1420 _index = 0;
1421 }
1422 public:
1423
1424 enum {
1425 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1426 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1427 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1428 trace_next_offset = java_lang_Throwable::trace_next_offset,
1429 trace_size = java_lang_Throwable::trace_size,
1430 trace_chunk_size = java_lang_Throwable::trace_chunk_size
1431 };
1432
1433 // get info out of chunks
1434 static typeArrayOop get_methods(objArrayHandle chunk) {
1435 typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset));
1436 assert(methods != NULL, "method array should be initialized in backtrace");
1437 return methods;
1438 }
1439 static typeArrayOop get_bcis(objArrayHandle chunk) {
1440 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1441 assert(bcis != NULL, "bci array should be initialized in backtrace");
1442 return bcis;
1443 }
1444 static objArrayOop get_mirrors(objArrayHandle chunk) {
1445 objArrayOop mirrors = objArrayOop(chunk->obj_at(trace_mirrors_offset));
1446 assert(mirrors != NULL, "mirror array should be initialized in backtrace");
1447 return mirrors;
1448 }
1449
1450 // constructor for new backtrace
1451 BacktraceBuilder(Handle throwable, TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL) {
1452 expand(CHECK);
1453 _backtrace = _head;
1454 _index = 0;
1455 add_backtrace(throwable);
1456 }
1457
1458 BacktraceBuilder(objArrayHandle backtrace) {
1459 _methods = get_methods(backtrace);
1460 _bcis = get_bcis(backtrace);
1461 _mirrors = get_mirrors(backtrace);
1462 assert(_methods->length() == _bcis->length() &&
1463 _methods->length() == _mirrors->length(),
1464 "method and source information arrays should match");
1465
1466 // head is the preallocated backtrace
1467 _backtrace = _head = backtrace();
1468 _index = 0;
1469 }
1470
1471 oop backtrace() {
1472 return _backtrace();
1473 }
1474
1475 inline void push(Method* method, int bci, TRAPS) {
1476 // Smear the -1 bci to 0 since the array only holds unsigned
1477 // shorts. The later line number lookup would just smear the -1
1478 // to a 0 even if it could be recorded.
1479 if (bci == SynchronizationEntryBCI) bci = 0;
1480
1481 if (_index >= trace_chunk_size) {
1482 methodHandle mhandle(THREAD, method);
1483 expand(CHECK);
1484 method = mhandle();
1485 }
1486
1487 _methods->metadata_at_put(_index, method);
1488 _bcis->int_at_put(_index, merge_bci_and_version(bci, method->constants()->version()));
1489
1490 // We need to save the mirrors in the backtrace to keep the class
1491 // from being unloaded while we still have this stack trace.
1492 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1493 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1494 _index++;
1495 }
1496
1497 };
1498
1499 Symbol* get_source_file_name(InstanceKlass* holder, int version) {
1500 // Find the specific ik version that contains this source_file_name_index
1501 // via the previous versions list, but use the current version's
1502 // constant pool to look it up. The previous version's index has been
1503 // merged for the current constant pool.
1504 InstanceKlass* ik = holder->get_klass_version(version);
1505 // This version has been cleaned up.
1506 if (ik == NULL) return NULL;
1507 int source_file_name_index = ik->source_file_name_index();
1508 return (source_file_name_index == 0) ?
1509 (Symbol*)NULL : holder->constants()->symbol_at(source_file_name_index);
1510 }
1511
1512 // Print stack trace element to resource allocated buffer
1513 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
1514 const methodHandle& method, int version, int bci) {
1515
1516 // Get strings and string lengths
1517 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1518 const char* klass_name = holder->external_name();
1519 int buf_len = (int)strlen(klass_name);
1520
1521 Symbol* sym = method->name();
1522 char* method_name = sym->as_C_string();
1523 buf_len += (int)strlen(method_name);
1524
1525 char* source_file_name = NULL;
1526 Symbol* source = get_source_file_name(holder, version);
1527 if (source != NULL) {
1528 source_file_name = source->as_C_string();
1529 buf_len += (int)strlen(source_file_name);
1530 }
1531
1532 // Allocate temporary buffer with extra space for formatting and line number
1533 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);
1534
1535 // Print stack trace line in buffer
1536 sprintf(buf, "\tat %s.%s", klass_name, method_name);
1537
1538 int line_number = get_line_number(method, bci);
1539 if (line_number == -2) {
1540 strcat(buf, "(Native Method)");
1541 } else {
1542 if (source_file_name != NULL && (line_number != -1)) {
1543 // Sourcename and linenumber
1544 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1545 } else if (source_file_name != NULL) {
1546 // Just sourcename
1547 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1548 } else {
1549 // Neither sourcename nor linenumber
1550 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1551 }
1552 nmethod* nm = method->code();
1553 if (WizardMode && nm != NULL) {
1554 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1555 }
1556 }
1557
1558 return buf;
1559 }
1560
1561 void java_lang_Throwable::print_stack_element(outputStream *st, Handle mirror,
1562 const methodHandle& method, int version, int bci) {
1563 ResourceMark rm;
1564 char* buf = print_stack_element_to_buffer(mirror, method, version, bci);
1565 st->print_cr("%s", buf);
1566 }
1567
1568 void java_lang_Throwable::print_stack_element(outputStream *st, const methodHandle& method, int bci) {
1569 Handle mirror = method->method_holder()->java_mirror();
1570 int version = method->constants()->version();
1571 print_stack_element(st, mirror, method, version, bci);
1572 }
1573
1574 const char* java_lang_Throwable::no_stack_trace_message() {
1575 return "\t<<no stack trace available>>";
1576 }
1577
1578
1579 // Currently used only for exceptions occurring during startup
1580 void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) {
1581 Thread *THREAD = Thread::current();
1582 Handle h_throwable(THREAD, throwable);
1583 while (h_throwable.not_null()) {
1584 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
1585 if (result.is_null()) {
1586 st->print_raw_cr(no_stack_trace_message());
1587 return;
1588 }
1589
1590 while (result.not_null()) {
1591
1592 // Get method id, bci, version and mirror from chunk
1593 typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
1594 typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
1595 objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
1596
1597 int length = methods()->length();
1598 for (int index = 0; index < length; index++) {
1599 Handle mirror(THREAD, mirrors->obj_at(index));
1600 // NULL mirror means end of stack trace
1601 if (mirror.is_null()) goto handle_cause;
1602 methodHandle method(THREAD, (Method*)methods->metadata_at(index));
1603 int version = version_at(bcis->int_at(index));
1604 int bci = bci_at(bcis->int_at(index));
1605 print_stack_element(st, mirror, method, version, bci);
1606 }
1607 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
1608 }
1609 handle_cause:
1610 {
1611 EXCEPTION_MARK;
1612 JavaValue cause(T_OBJECT);
1613 JavaCalls::call_virtual(&cause,
1614 h_throwable,
1615 KlassHandle(THREAD, h_throwable->klass()),
1616 vmSymbols::getCause_name(),
1617 vmSymbols::void_throwable_signature(),
1618 THREAD);
1619 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1620 if (HAS_PENDING_EXCEPTION) {
1621 CLEAR_PENDING_EXCEPTION;
1622 h_throwable = Handle();
1623 } else {
1624 h_throwable = Handle(THREAD, (oop) cause.get_jobject());
1625 if (h_throwable.not_null()) {
1628 st->cr();
1629 }
1630 }
1631 }
1632 }
1633 }
1634
1635 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method, TRAPS) {
1636 if (!StackTraceInThrowable) return;
1637 ResourceMark rm(THREAD);
1638
1639 // Start out by clearing the backtrace for this object, in case the VM
1640 // runs out of memory while allocating the stack trace
1641 set_backtrace(throwable(), NULL);
1642 // Clear lazily constructed Java level stacktrace if refilling occurs
1643 // This is unnecessary in 1.7+ but harmless
1644 clear_stacktrace(throwable());
1645
1646 int max_depth = MaxJavaStackTraceDepth;
1647 JavaThread* thread = (JavaThread*)THREAD;
1648 BacktraceBuilder bt(throwable, CHECK);
1649
1650 // If there is no Java frame just return the method that was being called
1651 // with bci 0
1652 if (!thread->has_last_Java_frame()) {
1653 if (max_depth >= 1 && method() != NULL) {
1654 bt.push(method(), 0, CHECK);
1655 set_backtrace(throwable(), bt.backtrace());
1656 }
1657 return;
1658 }
1659
1660 // Instead of using vframe directly, this version of fill_in_stack_trace
1661 // basically handles everything by hand. This significantly improved the
1662 // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows.
1663 // See bug 6333838 for more details.
1664 // The "ASSERT" here is to verify this method generates the exactly same stack
1665 // trace as utilizing vframe.
1666 #ifdef ASSERT
1667 vframeStream st(thread);
1668 methodHandle st_method(THREAD, st.method());
1770 }
1771
1772 // Disable stack traces for some preallocated out of memory errors
1773 if (!Universe::should_fill_in_stack_trace(throwable)) {
1774 return;
1775 }
1776
1777 PRESERVE_EXCEPTION_MARK;
1778
1779 JavaThread* thread = JavaThread::active();
1780 fill_in_stack_trace(throwable, method, thread);
1781 // ignore exceptions thrown during stack trace filling
1782 CLEAR_PENDING_EXCEPTION;
1783 }
1784
1785 void java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) {
1786 // Allocate stack trace - backtrace is created but not filled in
1787
1788 // No-op if stack trace is disabled
1789 if (!StackTraceInThrowable) return;
1790 BacktraceBuilder bt(throwable, CHECK); // creates a backtrace
1791 set_backtrace(throwable(), bt.backtrace());
1792 }
1793
1794
1795 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) {
1796 // Fill in stack trace into preallocated backtrace (no GC)
1797
1798 // No-op if stack trace is disabled
1799 if (!StackTraceInThrowable) return;
1800
1801 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check");
1802
1803 JavaThread* THREAD = JavaThread::current();
1804
1805 objArrayHandle backtrace (THREAD, (objArrayOop)java_lang_Throwable::backtrace(throwable()));
1806 assert(backtrace.not_null(), "backtrace should have been preallocated");
1807
1808 ResourceMark rm(THREAD);
1809 vframeStream st(THREAD);
1810
1861
1862
1863 oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) {
1864 if (throwable == NULL) {
1865 THROW_0(vmSymbols::java_lang_NullPointerException());
1866 }
1867 if (index < 0) {
1868 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1869 }
1870 // Compute how many chunks to skip and index into actual chunk
1871 objArrayOop chunk = objArrayOop(backtrace(throwable));
1872 int skip_chunks = index / trace_chunk_size;
1873 int chunk_index = index % trace_chunk_size;
1874 while (chunk != NULL && skip_chunks > 0) {
1875 chunk = objArrayOop(chunk->obj_at(trace_next_offset));
1876 skip_chunks--;
1877 }
1878 if (chunk == NULL) {
1879 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1880 }
1881 // Get method id, bci, version, mirror from chunk
1882 typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
1883 typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
1884 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
1885
1886 assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
1887
1888 methodHandle method(THREAD, (Method*)methods->metadata_at(chunk_index));
1889 int version = version_at(bcis->int_at(chunk_index));
1890 int bci = bci_at(bcis->int_at(chunk_index));
1891 Handle mirror(THREAD, mirrors->obj_at(chunk_index));
1892
1893 // Chunk can be partial full
1894 if (mirror.is_null()) {
1895 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1896 }
1897 oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, CHECK_0);
1898 return element;
1899 }
1900
1901 oop java_lang_StackTraceElement::create(Handle mirror, const methodHandle& method,
1902 int version, int bci, TRAPS) {
1903 // Allocate java.lang.StackTraceElement instance
1904 Klass* k = SystemDictionary::StackTraceElement_klass();
1905 assert(k != NULL, "must be loaded in 1.4+");
1906 instanceKlassHandle ik (THREAD, k);
1907 if (ik->should_be_initialized()) {
1908 ik->initialize(CHECK_0);
1909 }
1910
1911 Handle element = ik->allocate_instance_handle(CHECK_0);
1912 // Fill in class name
1913 ResourceMark rm(THREAD);
1914 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1915 const char* str = holder->external_name();
1916 oop classname = StringTable::intern((char*) str, CHECK_0);
1917 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1918
1919 // Fill in method name
1920 oop methodname = StringTable::intern(method->name(), CHECK_0);
1921 java_lang_StackTraceElement::set_methodName(element(), methodname);
1922
1923 // Fill in source file name and line number.
1924 Symbol* source = get_source_file_name(holder, version);
1925 if (ShowHiddenFrames && source == NULL)
1926 source = vmSymbols::unknown_class_name();
1927 oop filename = StringTable::intern(source, CHECK_0);
1928 java_lang_StackTraceElement::set_fileName(element(), filename);
1929
1930 int line_number = get_line_number(method, bci);
1931 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1932 return element();
1933 }
1934
1935 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
1936 Handle mirror (THREAD, method->method_holder()->java_mirror());
1937 return create(mirror, method, method->constants()->version(), bci, THREAD);
1938 }
1939
1940 void java_lang_reflect_AccessibleObject::compute_offsets() {
1941 Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
1942 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
1943 }
1944
1945 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
1946 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1947 return (jboolean) reflect->bool_field(override_offset);
1948 }
1949
1950 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
1951 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1952 reflect->bool_field_put(override_offset, (int) value);
1953 }
1954
1955 void java_lang_reflect_Method::compute_offsets() {
1956 Klass* k = SystemDictionary::reflect_Method_klass();
1957 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
|