1298 if (msg != NULL) {
1299 st->print(": %s", java_lang_String::as_utf8_string(msg));
1300 }
1301 }
1302
1303
1304 void java_lang_Throwable::print(Handle throwable, outputStream* st) {
1305 ResourceMark rm;
1306 Klass* k = throwable->klass();
1307 assert(k != NULL, "just checking");
1308 st->print("%s", InstanceKlass::cast(k)->external_name());
1309 oop msg = message(throwable);
1310 if (msg != NULL) {
1311 st->print(": %s", java_lang_String::as_utf8_string(msg));
1312 }
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,
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
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 {
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(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());
1973 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1974 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
3251 int java_lang_boxing_object::value_offset;
3252 int java_lang_boxing_object::long_value_offset;
3253 int java_lang_ref_Reference::referent_offset;
3254 int java_lang_ref_Reference::queue_offset;
3255 int java_lang_ref_Reference::next_offset;
3256 int java_lang_ref_Reference::discovered_offset;
3257 int java_lang_ref_Reference::static_lock_offset;
3258 int java_lang_ref_Reference::static_pending_offset;
3259 int java_lang_ref_Reference::number_of_fake_oop_fields;
3260 int java_lang_ref_SoftReference::timestamp_offset;
3261 int java_lang_ref_SoftReference::static_clock_offset;
3262 int java_lang_ClassLoader::parent_offset;
3263 int java_lang_System::static_in_offset;
3264 int java_lang_System::static_out_offset;
3265 int java_lang_System::static_err_offset;
3266 int java_lang_System::static_security_offset;
3267 int java_lang_StackTraceElement::declaringClass_offset;
3268 int java_lang_StackTraceElement::methodName_offset;
3269 int java_lang_StackTraceElement::fileName_offset;
3270 int java_lang_StackTraceElement::lineNumber_offset;
3271 int java_lang_AssertionStatusDirectives::classes_offset;
3272 int java_lang_AssertionStatusDirectives::classEnabled_offset;
3273 int java_lang_AssertionStatusDirectives::packages_offset;
3274 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
3275 int java_lang_AssertionStatusDirectives::deflt_offset;
3276 int java_nio_Buffer::_limit_offset;
3277 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0;
3278 int sun_reflect_ConstantPool::_oop_offset;
3279 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset;
3280
3281
3282 // Support for java_lang_StackTraceElement
3283
3284 void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
3285 element->obj_field_put(fileName_offset, value);
3286 }
3287
3288 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
3289 element->obj_field_put(declaringClass_offset, value);
3290 }
3291
3292 void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
3293 element->obj_field_put(methodName_offset, value);
3294 }
3295
3296 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
3297 element->int_field_put(lineNumber_offset, value);
3298 }
3299
3300
3301 // Support for java Assertions - java_lang_AssertionStatusDirectives.
3302
3303 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
3304 o->obj_field_put(classes_offset, val);
3305 }
3306
3307 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
3308 o->obj_field_put(classEnabled_offset, val);
3309 }
3310
3311 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
3312 o->obj_field_put(packages_offset, val);
3313 }
3314
3315 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
3316 o->obj_field_put(packageEnabled_offset, val);
3317 }
3318
3319 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
3413 java_lang_invoke_MethodHandle::compute_offsets();
3414 java_lang_invoke_DirectMethodHandle::compute_offsets();
3415 java_lang_invoke_MemberName::compute_offsets();
3416 java_lang_invoke_LambdaForm::compute_offsets();
3417 java_lang_invoke_MethodType::compute_offsets();
3418 java_lang_invoke_CallSite::compute_offsets();
3419 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets();
3420 java_security_AccessControlContext::compute_offsets();
3421 // Initialize reflection classes. The layouts of these classes
3422 // changed with the new reflection implementation in JDK 1.4, and
3423 // since the Universe doesn't know what JDK version it is until this
3424 // point we defer computation of these offsets until now.
3425 java_lang_reflect_AccessibleObject::compute_offsets();
3426 java_lang_reflect_Method::compute_offsets();
3427 java_lang_reflect_Constructor::compute_offsets();
3428 java_lang_reflect_Field::compute_offsets();
3429 java_nio_Buffer::compute_offsets();
3430 sun_reflect_ConstantPool::compute_offsets();
3431 sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
3432 java_lang_reflect_Parameter::compute_offsets();
3433
3434 // generated interpreter code wants to know about the offsets we just computed:
3435 AbstractAssembler::update_delayed_values();
3436 }
3437
3438 #ifndef PRODUCT
3439
3440 // These functions exist to assert the validity of hard-coded field offsets to guard
3441 // against changes in the class files
3442
3443 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
3444 EXCEPTION_MARK;
3445 fieldDescriptor fd;
3446 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3447 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
3448 instanceKlassHandle h_klass (THREAD, k);
3449 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
3450 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
3451 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
3452 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
|
1298 if (msg != NULL) {
1299 st->print(": %s", java_lang_String::as_utf8_string(msg));
1300 }
1301 }
1302
1303
1304 void java_lang_Throwable::print(Handle throwable, outputStream* st) {
1305 ResourceMark rm;
1306 Klass* k = throwable->klass();
1307 assert(k != NULL, "just checking");
1308 st->print("%s", InstanceKlass::cast(k)->external_name());
1309 oop msg = message(throwable);
1310 if (msg != NULL) {
1311 st->print(": %s", java_lang_String::as_utf8_string(msg));
1312 }
1313 }
1314
1315 // After this many redefines, the stack trace is unreliable.
1316 const int MAX_VERSION = USHRT_MAX;
1317
1318 static inline bool version_matches(Method* method, int version) {
1319 assert(version < MAX_VERSION, "version is too big");
1320 return method != NULL && (method->constants()->version() == version);
1321 }
1322
1323 // This class provides a simple wrapper over the internal structure of
1324 // exception backtrace to insulate users of the backtrace from needing
1325 // to know what it looks like.
1326 class BacktraceBuilder: public StackObj {
1327 private:
1328 Handle _backtrace;
1329 objArrayOop _head;
1330 typeArrayOop _methods;
1331 typeArrayOop _bcis;
1332 objArrayOop _mirrors;
1333 typeArrayOop _cprefs; // needed to insulate method name against redefinition
1334 int _index;
1335 No_Safepoint_Verifier _nsv;
1336
1337 public:
1338
1339 enum {
1340 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1341 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1342 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
1424 _index = 0;
1425 }
1426
1427 oop backtrace() {
1428 return _backtrace();
1429 }
1430
1431 inline void push(Method* method, int bci, TRAPS) {
1432 // Smear the -1 bci to 0 since the array only holds unsigned
1433 // shorts. The later line number lookup would just smear the -1
1434 // to a 0 even if it could be recorded.
1435 if (bci == SynchronizationEntryBCI) bci = 0;
1436
1437 if (_index >= trace_chunk_size) {
1438 methodHandle mhandle(THREAD, method);
1439 expand(CHECK);
1440 method = mhandle();
1441 }
1442
1443 _methods->short_at_put(_index, method->orig_method_idnum());
1444 _bcis->int_at_put(_index, BackTrace::merge_bci_and_version(bci, method->constants()->version()));
1445 _cprefs->short_at_put(_index, method->name_index());
1446
1447 // We need to save the mirrors in the backtrace to keep the class
1448 // from being unloaded while we still have this stack trace.
1449 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
1450 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
1451 _index++;
1452 }
1453
1454 };
1455
1456 // Print stack trace element to resource allocated buffer
1457 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
1458 int method_id, int version, int bci, int cpref) {
1459
1460 // Get strings and string lengths
1461 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1462 const char* klass_name = holder->external_name();
1463 int buf_len = (int)strlen(klass_name);
1464
1465 Method* method = holder->method_with_orig_idnum(method_id, version);
1466
1467 // The method can be NULL if the requested class version is gone
1468 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1469 char* method_name = sym->as_C_string();
1470 buf_len += (int)strlen(method_name);
1471
1472 char* source_file_name = NULL;
1473 Symbol* source = BackTrace::get_source_file_name(holder, version);
1474 if (source != NULL) {
1475 source_file_name = source->as_C_string();
1476 buf_len += (int)strlen(source_file_name);
1477 }
1478
1479 // Allocate temporary buffer with extra space for formatting and line number
1480 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);
1481
1482 // Print stack trace line in buffer
1483 sprintf(buf, "\tat %s.%s", klass_name, method_name);
1484
1485 if (!version_matches(method, version)) {
1486 strcat(buf, "(Redefined)");
1487 } else {
1488 int line_number = BackTrace::get_line_number(method, bci);
1489 if (line_number == -2) {
1490 strcat(buf, "(Native Method)");
1491 } else {
1492 if (source_file_name != NULL && (line_number != -1)) {
1493 // Sourcename and linenumber
1494 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
1495 } else if (source_file_name != NULL) {
1496 // Just sourcename
1497 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
1498 } else {
1499 // Neither sourcename nor linenumber
1500 sprintf(buf + (int)strlen(buf), "(Unknown Source)");
1501 }
1502 nmethod* nm = method->code();
1503 if (WizardMode && nm != NULL) {
1504 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
1505 }
1506 }
1507 }
1508
1537 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
1538 if (result.is_null()) {
1539 st->print_raw_cr(no_stack_trace_message());
1540 return;
1541 }
1542
1543 while (result.not_null()) {
1544
1545 // Get method id, bci, version and mirror from chunk
1546 typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
1547 typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
1548 objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
1549 typeArrayHandle cprefs (THREAD, BacktraceBuilder::get_cprefs(result));
1550
1551 int length = methods()->length();
1552 for (int index = 0; index < length; index++) {
1553 Handle mirror(THREAD, mirrors->obj_at(index));
1554 // NULL mirror means end of stack trace
1555 if (mirror.is_null()) goto handle_cause;
1556 int method = methods->short_at(index);
1557 int version = BackTrace::version_at(bcis->int_at(index));
1558 int bci = BackTrace::bci_at(bcis->int_at(index));
1559 int cpref = cprefs->short_at(index);
1560 print_stack_element(st, mirror, method, version, bci, cpref);
1561 }
1562 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
1563 }
1564 handle_cause:
1565 {
1566 EXCEPTION_MARK;
1567 JavaValue cause(T_OBJECT);
1568 JavaCalls::call_virtual(&cause,
1569 h_throwable,
1570 KlassHandle(THREAD, h_throwable->klass()),
1571 vmSymbols::getCause_name(),
1572 vmSymbols::void_throwable_signature(),
1573 THREAD);
1574 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
1575 if (HAS_PENDING_EXCEPTION) {
1576 CLEAR_PENDING_EXCEPTION;
1577 h_throwable = Handle();
1578 } else {
1825 // Compute how many chunks to skip and index into actual chunk
1826 objArrayOop chunk = objArrayOop(backtrace(throwable));
1827 int skip_chunks = index / trace_chunk_size;
1828 int chunk_index = index % trace_chunk_size;
1829 while (chunk != NULL && skip_chunks > 0) {
1830 chunk = objArrayOop(chunk->obj_at(trace_next_offset));
1831 skip_chunks--;
1832 }
1833 if (chunk == NULL) {
1834 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1835 }
1836 // Get method id, bci, version, mirror and cpref from chunk
1837 typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
1838 typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
1839 objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
1840 typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
1841
1842 assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
1843
1844 int method = methods->short_at(chunk_index);
1845 int version = BackTrace::version_at(bcis->int_at(chunk_index));
1846 int bci = BackTrace::bci_at(bcis->int_at(chunk_index));
1847 int cpref = cprefs->short_at(chunk_index);
1848 Handle mirror(THREAD, mirrors->obj_at(chunk_index));
1849
1850 // Chunk can be partial full
1851 if (mirror.is_null()) {
1852 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1853 }
1854 oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, cpref, CHECK_0);
1855 return element;
1856 }
1857
1858 oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
1859 int version, int bci, int cpref, TRAPS) {
1860 // Allocate java.lang.StackTraceElement instance
1861 Klass* k = SystemDictionary::StackTraceElement_klass();
1862 assert(k != NULL, "must be loaded in 1.4+");
1863 instanceKlassHandle ik (THREAD, k);
1864 if (ik->should_be_initialized()) {
1865 ik->initialize(CHECK_0);
1866 }
1867
1868 Handle element = ik->allocate_instance_handle(CHECK_0);
1869 java_lang_StackTraceElement::init(element, mirror, method_id, version, bci, cpref, CHECK_0);
1870 return element();
1871 }
1872
1873 void java_lang_StackTraceElement::init(Handle element, Handle mirror, int method_id,
1874 int version, int bci, int cpref, TRAPS) {
1875
1876 // Fill in class name
1877 ResourceMark rm(THREAD);
1878 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
1879 const char* str = holder->external_name();
1880 oop classname = StringTable::intern((char*) str, CHECK);
1881 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1882
1883 Method* method = holder->method_with_orig_idnum(method_id, version);
1884
1885 // The method can be NULL if the requested class version is gone
1886 Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
1887
1888 // Fill in method name
1889 oop methodname = StringTable::intern(sym, CHECK);
1890 java_lang_StackTraceElement::set_methodName(element(), methodname);
1891
1892 if (!version_matches(method, version)) {
1893 // The method was redefined, accurate line number information isn't available
1894 java_lang_StackTraceElement::set_fileName(element(), NULL);
1895 java_lang_StackTraceElement::set_lineNumber(element(), -1);
1896 } else {
1897 // Fill in source file name and line number.
1898 Symbol* source = BackTrace::get_source_file_name(holder, version);
1899 if (ShowHiddenFrames && source == NULL)
1900 source = vmSymbols::unknown_class_name();
1901 oop filename = StringTable::intern(source, CHECK);
1902 java_lang_StackTraceElement::set_fileName(element(), filename);
1903
1904 int line_number = BackTrace::get_line_number(method, bci);
1905 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1906 }
1907 }
1908
1909 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
1910 Handle mirror (THREAD, method->method_holder()->java_mirror());
1911 int method_id = method->orig_method_idnum();
1912 int cpref = method->name_index();
1913 return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
1914 }
1915
1916 int java_lang_StackFrameInfo::bci(oop stackFrame) {
1917 int value = stackFrame->int_field(bci_offset);
1918 if (MemberNameInStackFrame) {
1919 return value;
1920 } else {
1921 return BackTrace::bci_at(value);
1922 }
1923 }
1924
1925 oop java_lang_StackFrameInfo::member_name(oop stackFrame) {
1926 return stackFrame->obj_field(memberName_offset);
1927 }
1928
1929 Method* java_lang_StackFrameInfo::get_method(Handle stackFrame, InstanceKlass* holder, TRAPS) {
1930 if (MemberNameInStackFrame) {
1931 Handle mname(THREAD, stackFrame->obj_field(memberName_offset));
1932 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mname());
1933 // we should expand MemberName::name when Throwable uses StackTrace
1934 // MethodHandles::expand_MemberName(mname, MethodHandles::_suppress_defc|MethodHandles::_suppress_type, CHECK_NULL);
1935 return method;
1936 } else {
1937 int bci_version = stackFrame->int_field(bci_offset);
1938 int version = BackTrace::version_at(bci_version);
1939 int mid_cpref = stackFrame->int_field(mid_offset);
1940 int mid = BackTrace::mid_at(mid_cpref);
1941 int cpref = BackTrace::cpref_at(mid_cpref);
1942 return holder->method_with_orig_idnum(mid, version);
1943 }
1944 }
1945
1946 Symbol* java_lang_StackFrameInfo::get_file_name(Handle stackFrame, InstanceKlass* holder) {
1947 if (MemberNameInStackFrame) {
1948 return holder->source_file_name();
1949 } else {
1950 int bci_version = stackFrame->int_field(bci_offset);
1951 int version = BackTrace::version_at(bci_version);
1952 Symbol* source = BackTrace::get_source_file_name(holder, version);
1953 if (source == NULL) {
1954 source = vmSymbols::unknown_class_name();
1955 }
1956 return source;
1957 }
1958 }
1959
1960 void java_lang_StackFrameInfo::fill_methodInfo(Handle stackFrame, TRAPS) {
1961 ResourceMark rm(THREAD);
1962 oop k = stackFrame->obj_field(declaringClass_offset);
1963 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(k));
1964 Method* method = java_lang_StackFrameInfo::get_method(stackFrame, holder, CHECK);
1965 int bci = java_lang_StackFrameInfo::bci(stackFrame());
1966
1967 // The method can be NULL if the requested class version is gone
1968 Symbol* sym = (method != NULL) ? method->name() : NULL;
1969 if (MemberNameInStackFrame) {
1970 assert(sym != NULL, "MemberName must have method name");
1971 } else {
1972 bci = BackTrace::bci_at(bci); // merged with version
1973 // The method can be NULL if the requested class version is gone
1974 if (sym == NULL) {
1975 int mid_cpref = stackFrame->int_field(mid_offset);
1976 int cpref = BackTrace::cpref_at(mid_cpref);
1977 sym = holder->constants()->symbol_at(cpref);
1978 }
1979 }
1980
1981 // set method name
1982 oop methodname = StringTable::intern(sym, CHECK);
1983 java_lang_StackFrameInfo::set_methodName(stackFrame(), methodname);
1984
1985 // set file name and line number
1986 Symbol* source = get_file_name(stackFrame, holder);
1987 if (source != NULL) {
1988 oop filename = StringTable::intern(source, CHECK);
1989 java_lang_StackFrameInfo::set_fileName(stackFrame(), filename);
1990 }
1991 if (method != NULL) {
1992 int line_number = BackTrace::get_line_number(method, bci);
1993 java_lang_StackFrameInfo::set_lineNumber(stackFrame(), line_number);
1994 }
1995 }
1996
1997 void java_lang_StackFrameInfo::compute_offsets() {
1998 Klass* k = SystemDictionary::StackFrameInfo_klass();
1999 compute_offset(declaringClass_offset, k, vmSymbols::declaringClass_name(), vmSymbols::class_signature());
2000 compute_offset(memberName_offset, k, vmSymbols::memberName_name(), vmSymbols::object_signature());
2001 compute_offset(mid_offset, k, vmSymbols::mid_name(), vmSymbols::int_signature());
2002 compute_offset(bci_offset, k, vmSymbols::bci_name(), vmSymbols::int_signature());
2003 compute_offset(methodName_offset, k, vmSymbols::methodName_name(), vmSymbols::string_signature());
2004 compute_offset(fileName_offset, k, vmSymbols::fileName_name(), vmSymbols::string_signature());
2005 compute_offset(lineNumber_offset, k, vmSymbols::lineNumber_name(), vmSymbols::int_signature());
2006 }
2007
2008 void java_lang_LiveStackFrameInfo::compute_offsets() {
2009 Klass* k = SystemDictionary::LiveStackFrameInfo_klass();
2010 compute_offset(monitors_offset, k, vmSymbols::monitors_name(), vmSymbols::object_array_signature());
2011 compute_offset(locals_offset, k, vmSymbols::locals_name(), vmSymbols::object_array_signature());
2012 compute_offset(operands_offset, k, vmSymbols::operands_name(), vmSymbols::object_array_signature());
2013 }
2014
2015 void java_lang_reflect_AccessibleObject::compute_offsets() {
2016 Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
2017 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
2018 }
2019
2020 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
2021 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2022 return (jboolean) reflect->bool_field(override_offset);
2023 }
2024
2025 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
2026 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2027 reflect->bool_field_put(override_offset, (int) value);
2028 }
2029
2030 void java_lang_reflect_Method::compute_offsets() {
2031 Klass* k = SystemDictionary::reflect_Method_klass();
2032 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
2033 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
2034 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
3311 int java_lang_boxing_object::value_offset;
3312 int java_lang_boxing_object::long_value_offset;
3313 int java_lang_ref_Reference::referent_offset;
3314 int java_lang_ref_Reference::queue_offset;
3315 int java_lang_ref_Reference::next_offset;
3316 int java_lang_ref_Reference::discovered_offset;
3317 int java_lang_ref_Reference::static_lock_offset;
3318 int java_lang_ref_Reference::static_pending_offset;
3319 int java_lang_ref_Reference::number_of_fake_oop_fields;
3320 int java_lang_ref_SoftReference::timestamp_offset;
3321 int java_lang_ref_SoftReference::static_clock_offset;
3322 int java_lang_ClassLoader::parent_offset;
3323 int java_lang_System::static_in_offset;
3324 int java_lang_System::static_out_offset;
3325 int java_lang_System::static_err_offset;
3326 int java_lang_System::static_security_offset;
3327 int java_lang_StackTraceElement::declaringClass_offset;
3328 int java_lang_StackTraceElement::methodName_offset;
3329 int java_lang_StackTraceElement::fileName_offset;
3330 int java_lang_StackTraceElement::lineNumber_offset;
3331 int java_lang_StackFrameInfo::declaringClass_offset;
3332 int java_lang_StackFrameInfo::memberName_offset;
3333 int java_lang_StackFrameInfo::mid_offset;
3334 int java_lang_StackFrameInfo::bci_offset;
3335 int java_lang_StackFrameInfo::methodName_offset;
3336 int java_lang_StackFrameInfo::fileName_offset;
3337 int java_lang_StackFrameInfo::lineNumber_offset;
3338 int java_lang_LiveStackFrameInfo::monitors_offset;
3339 int java_lang_LiveStackFrameInfo::locals_offset;
3340 int java_lang_LiveStackFrameInfo::operands_offset;
3341 int java_lang_AssertionStatusDirectives::classes_offset;
3342 int java_lang_AssertionStatusDirectives::classEnabled_offset;
3343 int java_lang_AssertionStatusDirectives::packages_offset;
3344 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
3345 int java_lang_AssertionStatusDirectives::deflt_offset;
3346 int java_nio_Buffer::_limit_offset;
3347 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0;
3348 int sun_reflect_ConstantPool::_oop_offset;
3349 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset;
3350
3351
3352 // Support for java_lang_StackTraceElement
3353
3354 void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
3355 element->obj_field_put(fileName_offset, value);
3356 }
3357
3358 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
3359 element->obj_field_put(declaringClass_offset, value);
3360 }
3361
3362 void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
3363 element->obj_field_put(methodName_offset, value);
3364 }
3365
3366 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
3367 element->int_field_put(lineNumber_offset, value);
3368 }
3369
3370 // Support for java_lang_StackFrameInfo
3371 void java_lang_StackFrameInfo::set_declaringClass(oop element, oop value) {
3372 element->obj_field_put(declaringClass_offset, value);
3373 }
3374
3375 void java_lang_StackFrameInfo::set_mid(oop element, int value) {
3376 element->int_field_put(mid_offset, value);
3377 }
3378 void java_lang_StackFrameInfo::set_bci(oop element, int value) {
3379 element->int_field_put(bci_offset, value);
3380 }
3381
3382 void java_lang_StackFrameInfo::set_fileName(oop element, oop value) {
3383 element->obj_field_put(fileName_offset, value);
3384 }
3385
3386 void java_lang_StackFrameInfo::set_methodName(oop element, oop value) {
3387 element->obj_field_put(methodName_offset, value);
3388 }
3389
3390 void java_lang_StackFrameInfo::set_lineNumber(oop element, int value) {
3391 element->int_field_put(lineNumber_offset, value);
3392 }
3393
3394 void java_lang_LiveStackFrameInfo::set_monitors(oop element, oop value) {
3395 element->obj_field_put(monitors_offset, value);
3396 }
3397
3398 void java_lang_LiveStackFrameInfo::set_locals(oop element, oop value) {
3399 element->obj_field_put(locals_offset, value);
3400 }
3401
3402 void java_lang_LiveStackFrameInfo::set_operands(oop element, oop value) {
3403 element->obj_field_put(operands_offset, value);
3404 }
3405
3406 // Support for java Assertions - java_lang_AssertionStatusDirectives.
3407
3408 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
3409 o->obj_field_put(classes_offset, val);
3410 }
3411
3412 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
3413 o->obj_field_put(classEnabled_offset, val);
3414 }
3415
3416 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
3417 o->obj_field_put(packages_offset, val);
3418 }
3419
3420 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
3421 o->obj_field_put(packageEnabled_offset, val);
3422 }
3423
3424 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
3518 java_lang_invoke_MethodHandle::compute_offsets();
3519 java_lang_invoke_DirectMethodHandle::compute_offsets();
3520 java_lang_invoke_MemberName::compute_offsets();
3521 java_lang_invoke_LambdaForm::compute_offsets();
3522 java_lang_invoke_MethodType::compute_offsets();
3523 java_lang_invoke_CallSite::compute_offsets();
3524 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets();
3525 java_security_AccessControlContext::compute_offsets();
3526 // Initialize reflection classes. The layouts of these classes
3527 // changed with the new reflection implementation in JDK 1.4, and
3528 // since the Universe doesn't know what JDK version it is until this
3529 // point we defer computation of these offsets until now.
3530 java_lang_reflect_AccessibleObject::compute_offsets();
3531 java_lang_reflect_Method::compute_offsets();
3532 java_lang_reflect_Constructor::compute_offsets();
3533 java_lang_reflect_Field::compute_offsets();
3534 java_nio_Buffer::compute_offsets();
3535 sun_reflect_ConstantPool::compute_offsets();
3536 sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
3537 java_lang_reflect_Parameter::compute_offsets();
3538 java_lang_StackFrameInfo::compute_offsets();
3539 java_lang_LiveStackFrameInfo::compute_offsets();
3540
3541 // generated interpreter code wants to know about the offsets we just computed:
3542 AbstractAssembler::update_delayed_values();
3543 }
3544
3545 #ifndef PRODUCT
3546
3547 // These functions exist to assert the validity of hard-coded field offsets to guard
3548 // against changes in the class files
3549
3550 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
3551 EXCEPTION_MARK;
3552 fieldDescriptor fd;
3553 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3554 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
3555 instanceKlassHandle h_klass (THREAD, k);
3556 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
3557 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
3558 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
3559 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
|