41 #include "classfile/modules.hpp"
42 #include "classfile/packageEntry.hpp"
43 #include "classfile/stringTable.hpp"
44 #include "classfile/symbolTable.hpp"
45 #include "classfile/systemDictionary.hpp"
46 #include "classfile/vmClasses.hpp"
47 #include "classfile/vmSymbols.hpp"
48 #include "gc/shared/collectedHeap.inline.hpp"
49 #include "interpreter/bytecode.hpp"
50 #include "interpreter/bytecodeUtils.hpp"
51 #include "jfr/jfrEvents.hpp"
52 #include "jvm.h"
53 #include "logging/log.hpp"
54 #include "memory/oopFactory.hpp"
55 #include "memory/referenceType.hpp"
56 #include "memory/resourceArea.hpp"
57 #include "memory/universe.hpp"
58 #include "oops/access.inline.hpp"
59 #include "oops/constantPool.hpp"
60 #include "oops/fieldStreams.inline.hpp"
61 #include "oops/instanceKlass.hpp"
62 #include "oops/klass.inline.hpp"
63 #include "oops/method.hpp"
64 #include "oops/objArrayKlass.hpp"
65 #include "oops/objArrayOop.inline.hpp"
66 #include "oops/oop.inline.hpp"
67 #include "oops/recordComponent.hpp"
68 #include "prims/foreignGlobals.hpp"
69 #include "prims/jvm_misc.hpp"
70 #include "prims/jvmtiExport.hpp"
71 #include "prims/jvmtiThreadState.inline.hpp"
72 #include "prims/stackwalk.hpp"
73 #include "runtime/arguments.hpp"
74 #include "runtime/atomicAccess.hpp"
75 #include "runtime/continuation.hpp"
76 #include "runtime/deoptimization.hpp"
77 #include "runtime/globals_extension.hpp"
78 #include "runtime/handles.inline.hpp"
79 #include "runtime/handshake.hpp"
80 #include "runtime/init.hpp"
81 #include "runtime/interfaceSupport.inline.hpp"
82 #include "runtime/java.hpp"
83 #include "runtime/javaCalls.hpp"
84 #include "runtime/javaThread.hpp"
85 #include "runtime/jfieldIDWorkaround.hpp"
86 #include "runtime/jniHandles.inline.hpp"
87 #include "runtime/mountUnmountDisabler.hpp"
407
408 return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
409 JVM_END
410
411
412 /*
413 * Return the temporary directory that the VM uses for the attach
414 * and perf data files.
415 *
416 * It is important that this directory is well-known and the
417 * same for all VM instances. It cannot be affected by configuration
418 * variables such as java.io.tmpdir.
419 */
420 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
421 HandleMark hm(THREAD);
422 const char* temp_dir = os::get_temp_directory();
423 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
424 return (jstring) JNIHandles::make_local(THREAD, h());
425 JVM_END
426
427
428 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
429
430 extern volatile jint vm_created;
431
432 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
433 EventShutdown event;
434 if (event.should_commit()) {
435 event.set_reason("Shutdown requested from Java");
436 event.commit();
437 }
438 JVM_END
439
440
441 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
442 before_exit(thread, true);
443 vm_exit(code);
444 JVM_END
445
446
524 }
525 if (method->is_native()) {
526 return nullptr;
527 }
528
529 stringStream ss;
530 bool ok = BytecodeUtils::get_NPE_message_at(&ss, method, bci);
531 if (ok) {
532 oop result = java_lang_String::create_oop_from_str(ss.base(), CHECK_NULL);
533 return (jstring) JNIHandles::make_local(THREAD, result);
534 } else {
535 return nullptr;
536 }
537 JVM_END
538
539 // java.lang.StackTraceElement //////////////////////////////////////////////
540
541
542 JVM_ENTRY(void, JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject backtrace, jint depth))
543 Handle backtraceh(THREAD, JNIHandles::resolve(backtrace));
544 objArrayOop st = objArrayOop(JNIHandles::resolve(elements));
545 objArrayHandle stack_trace(THREAD, st);
546 // Fill in the allocated stack trace
547 java_lang_Throwable::get_stack_trace_elements(depth, backtraceh, stack_trace, CHECK);
548 JVM_END
549
550
551 JVM_ENTRY(void, JVM_InitStackTraceElement(JNIEnv* env, jobject element, jobject stackFrameInfo))
552 Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(stackFrameInfo));
553 Handle stack_trace_element(THREAD, JNIHandles::resolve_non_null(element));
554 java_lang_StackFrameInfo::to_stack_trace_element(stack_frame_info, stack_trace_element, CHECK);
555 JVM_END
556
557
558 // java.lang.StackWalker //////////////////////////////////////////////////////
559 JVM_ENTRY(void, JVM_ExpandStackFrameInfo(JNIEnv *env, jobject obj))
560 Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(obj));
561
562 bool have_name = (java_lang_StackFrameInfo::name(stack_frame_info()) != nullptr);
563 bool have_type = (java_lang_StackFrameInfo::type(stack_frame_info()) != nullptr);
564 Method* method = java_lang_StackFrameInfo::get_method(stack_frame_info());
565 if (!have_name) {
568 }
569 if (!have_type) {
570 Handle type = java_lang_String::create_from_symbol(method->signature(), CHECK);
571 java_lang_StackFrameInfo::set_type(stack_frame_info(), type());
572 }
573 JVM_END
574
575 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode,
576 jint skip_frames, jobject contScope, jobject cont,
577 jint buffer_size, jint start_index, jobjectArray frames))
578 if (!thread->has_last_Java_frame()) {
579 THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", nullptr);
580 }
581
582 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
583 Handle contScope_h(THREAD, JNIHandles::resolve(contScope));
584 Handle cont_h(THREAD, JNIHandles::resolve(cont));
585 // frames array is a ClassFrameInfo[] array when only getting caller reference,
586 // and a StackFrameInfo[] array (or derivative) otherwise. It should never
587 // be null.
588 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
589 objArrayHandle frames_array_h(THREAD, fa);
590
591 if (frames_array_h->length() < buffer_size) {
592 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", nullptr);
593 }
594
595 oop result = StackWalk::walk(stackStream_h, mode, skip_frames, contScope_h, cont_h,
596 buffer_size, start_index, frames_array_h, CHECK_NULL);
597 return JNIHandles::make_local(THREAD, result);
598 JVM_END
599
600
601 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor,
602 jint last_batch_count, jint buffer_size, jint start_index,
603 jobjectArray frames))
604 // frames array is a ClassFrameInfo[] array when only getting caller reference,
605 // and a StackFrameInfo[] array (or derivative) otherwise. It should never
606 // be null.
607 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
608 objArrayHandle frames_array_h(THREAD, fa);
609
610 if (frames_array_h->length() < buffer_size) {
611 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");
612 }
613
614 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
615 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
616 start_index, frames_array_h, THREAD);
617 JVM_END
618
619 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
620 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
621 objArrayHandle frames_array_h(THREAD, fa);
622 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
623 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
624
625 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
626 JVM_END
627
628 // java.lang.Object ///////////////////////////////////////////////
629
630
631 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
632 // as implemented in the classic virtual machine; return 0 if object is null
633 return handle == nullptr ? 0 :
634 checked_cast<jint>(ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)));
635 JVM_END
636
637
638 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
639 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
640 ObjectSynchronizer::wait(obj, ms, CHECK);
641 JVM_END
642
643
644 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
645 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
646 ObjectSynchronizer::notify(obj, CHECK);
647 JVM_END
648
649
650 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
651 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
652 ObjectSynchronizer::notifyall(obj, CHECK);
653 JVM_END
654
662 // Just checking that the cloneable flag is set correct
663 if (obj->is_array()) {
664 guarantee(klass->is_cloneable(), "all arrays are cloneable");
665 } else {
666 guarantee(obj->is_instance(), "should be instanceOop");
667 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
668 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
669 }
670 #endif
671
672 // Check if class of obj supports the Cloneable interface.
673 // All arrays are considered to be cloneable (See JLS 20.1.5).
674 // All j.l.r.Reference classes are considered non-cloneable.
675 if (!klass->is_cloneable() ||
676 (klass->is_instance_klass() &&
677 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
678 ResourceMark rm(THREAD);
679 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
680 }
681
682 // Make shallow object copy
683 const size_t size = obj->size();
684 oop new_obj_oop = nullptr;
685 if (obj->is_array()) {
686 const int length = ((arrayOop)obj())->length();
687 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
688 /* do_zero */ true, CHECK_NULL);
689 } else {
690 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
691 }
692
693 HeapAccess<>::clone(obj(), new_obj_oop, size);
694
695 Handle new_obj(THREAD, new_obj_oop);
696 // Caution: this involves a java upcall, so the clone should be
697 // "gc-robust" by this stage.
698 if (klass->has_finalizer()) {
699 assert(obj->is_instance(), "should be instanceOop");
700 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
701 new_obj = Handle(THREAD, new_obj_oop);
1154 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1155 return (jstring) JNIHandles::make_local(THREAD, result);
1156 JVM_END
1157
1158
1159 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1160 JvmtiVMObjectAllocEventCollector oam;
1161 oop mirror = JNIHandles::resolve_non_null(cls);
1162
1163 // Special handling for primitive objects
1164 if (java_lang_Class::is_primitive(mirror)) {
1165 // Primitive objects does not have any interfaces
1166 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1167 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1168 }
1169
1170 Klass* klass = java_lang_Class::as_Klass(mirror);
1171 // Figure size of result array
1172 int size;
1173 if (klass->is_instance_klass()) {
1174 size = InstanceKlass::cast(klass)->local_interfaces()->length();
1175 } else {
1176 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1177 size = 2;
1178 }
1179
1180 // Allocate result array
1181 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1182 objArrayHandle result (THREAD, r);
1183 // Fill in result
1184 if (klass->is_instance_klass()) {
1185 // Regular instance klass, fill in all local interfaces
1186 for (int index = 0; index < size; index++) {
1187 InstanceKlass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1188 result->obj_at_put(index, k->java_mirror());
1189 }
1190 } else {
1191 // All arrays implement java.lang.Cloneable and java.io.Serializable
1192 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1193 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1194 }
1242
1243 return nullptr;
1244 JVM_END
1245
1246 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
1247 JvmtiVMObjectAllocEventCollector oam;
1248 // ofClass is a reference to a java_lang_Class object. The mirror object
1249 // of an InstanceKlass
1250 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1251 if (java_lang_Class::is_primitive(ofMirror) ||
1252 ! java_lang_Class::as_Klass(ofMirror)->is_instance_klass()) {
1253 oop result = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1254 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1255 }
1256
1257 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1258 InnerClassesIterator iter(k);
1259
1260 if (iter.length() == 0) {
1261 // Neither an inner nor outer class
1262 oop result = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1263 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1264 }
1265
1266 // find inner class info
1267 constantPoolHandle cp(thread, k->constants());
1268 int length = iter.length();
1269
1270 // Allocate temp. result array
1271 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), length/4, CHECK_NULL);
1272 objArrayHandle result (THREAD, r);
1273 int members = 0;
1274
1275 for (; !iter.done(); iter.next()) {
1276 int ioff = iter.inner_class_info_index();
1277 int ooff = iter.outer_class_info_index();
1278
1279 if (ioff != 0 && ooff != 0) {
1280 // Check to see if the name matches the class we're looking for
1281 // before attempting to find the class.
1282 if (cp->klass_name_at_matches(k, ooff)) {
1283 Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL);
1284 if (outer_klass == k) {
1285 Klass* ik = cp->klass_at(ioff, CHECK_NULL);
1286 InstanceKlass* inner_klass = InstanceKlass::cast(ik);
1287
1288 // Throws an exception if outer klass has not declared k as
1289 // an inner klass
1290 Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);
1291
1292 result->obj_at_put(members, inner_klass->java_mirror());
1293 members++;
1294 }
1295 }
1296 }
1297 }
1298
1299 if (members != length) {
1300 // Return array of right length
1301 objArrayOop res = oopFactory::new_objArray(vmClasses::Class_klass(), members, CHECK_NULL);
1302 for(int i = 0; i < members; i++) {
1303 res->obj_at_put(i, result->obj_at(i));
1304 }
1305 return (jobjectArray)JNIHandles::make_local(THREAD, res);
1306 }
1307
1308 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1309 JVM_END
1310
1311
1312 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1313 {
1314 // ofClass is a reference to a java_lang_Class object.
1315 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1316 if (java_lang_Class::is_primitive(ofMirror)) {
1317 return nullptr;
1318 }
1319 Klass* klass = java_lang_Class::as_Klass(ofMirror);
1320 if (!klass->is_instance_klass()) {
1321 return nullptr;
1658 }
1659
1660 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1661
1662 // Ensure class is linked
1663 k->link_class(CHECK_NULL);
1664
1665 Array<Method*>* methods = k->methods();
1666 int methods_length = methods->length();
1667
1668 // Save original method_idnum in case of redefinition, which can change
1669 // the idnum of obsolete methods. The new method will have the same idnum
1670 // but if we refresh the methods array, the counts will be wrong.
1671 ResourceMark rm(THREAD);
1672 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1673 int num_methods = 0;
1674
1675 // Select methods matching the criteria.
1676 for (int i = 0; i < methods_length; i++) {
1677 Method* method = methods->at(i);
1678 if (want_constructor && !method->is_object_initializer()) {
1679 continue;
1680 }
1681 if (!want_constructor &&
1682 (method->is_object_initializer() || method->is_static_initializer() ||
1683 method->is_overpass())) {
1684 continue;
1685 }
1686 if (publicOnly && !method->is_public()) {
1687 continue;
1688 }
1689 idnums->push(method->method_idnum());
1690 ++num_methods;
1691 }
1692
1693 // Allocate result
1694 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1695 objArrayHandle result (THREAD, r);
1696
1697 // Now just put the methods that we selected above, but go by their idnum
1698 // in case of redefinition. The methods can be redefined at any safepoint,
1699 // so above when allocating the oop array and below when creating reflect
1700 // objects.
1701 for (int i = 0; i < num_methods; i++) {
1702 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1703 if (method.is_null()) {
1704 // Method may have been deleted and seems this API can handle null
1705 // Otherwise should probably put a method that throws NSME
1706 result->obj_at_put(i, nullptr);
1707 } else {
1708 oop m;
1709 if (want_constructor) {
1710 m = Reflection::new_constructor(method, CHECK_NULL);
1711 } else {
1712 m = Reflection::new_method(method, false, CHECK_NULL);
1713 }
1714 result->obj_at_put(i, m);
1715 }
1716 }
1717
1718 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1719 }
1720
1721 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1722 {
1723 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1724 /*want_constructor*/ false,
1725 vmClasses::reflect_Method_klass(), THREAD);
1726 }
1727 JVM_END
1728
1729 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1752 }
1753 JVM_END
1754
1755 JVM_ENTRY(jobjectArray, JVM_GetNestMembers(JNIEnv* env, jclass current))
1756 {
1757 // current is not a primitive or array class
1758 ResourceMark rm(THREAD);
1759 InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
1760 InstanceKlass* host = c->nest_host(THREAD);
1761
1762 log_trace(class, nestmates)("Calling GetNestMembers for type %s with nest-host %s",
1763 c->external_name(), host->external_name());
1764 {
1765 JvmtiVMObjectAllocEventCollector oam;
1766 Array<u2>* members = host->nest_members();
1767 int length = members == nullptr ? 0 : members->length();
1768
1769 log_trace(class, nestmates)(" - host has %d listed nest members", length);
1770
1771 // nest host is first in the array so make it one bigger
1772 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(),
1773 length + 1, CHECK_NULL);
1774 objArrayHandle result(THREAD, r);
1775 result->obj_at_put(0, host->java_mirror());
1776 if (length != 0) {
1777 int count = 0;
1778 for (int i = 0; i < length; i++) {
1779 int cp_index = members->at(i);
1780 Klass* k = host->constants()->klass_at(cp_index, THREAD);
1781 if (HAS_PENDING_EXCEPTION) {
1782 if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) {
1783 return nullptr; // propagate VMEs
1784 }
1785 if (log_is_enabled(Trace, class, nestmates)) {
1786 stringStream ss;
1787 char* target_member_class = host->constants()->klass_name_at(cp_index)->as_C_string();
1788 ss.print(" - resolution of nest member %s failed: ", target_member_class);
1789 java_lang_Throwable::print(PENDING_EXCEPTION, &ss);
1790 log_trace(class, nestmates)("%s", ss.as_string());
1791 }
1792 CLEAR_PENDING_EXCEPTION;
1793 continue;
1794 }
1829 }
1830 }
1831 JVM_END
1832
1833 JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current))
1834 {
1835 oop mirror = JNIHandles::resolve_non_null(current);
1836 assert(!java_lang_Class::is_primitive(mirror), "should not be");
1837 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
1838
1839 ResourceMark rm(THREAD);
1840 log_trace(class, sealed)("Calling GetPermittedSubclasses for %s type %s",
1841 ik->is_sealed() ? "sealed" : "non-sealed", ik->external_name());
1842 if (ik->is_sealed()) {
1843 JvmtiVMObjectAllocEventCollector oam;
1844 Array<u2>* subclasses = ik->permitted_subclasses();
1845 int length = subclasses->length();
1846
1847 log_trace(class, sealed)(" - sealed class has %d permitted subclasses", length);
1848
1849 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(),
1850 length, CHECK_NULL);
1851 objArrayHandle result(THREAD, r);
1852 int count = 0;
1853 for (int i = 0; i < length; i++) {
1854 int cp_index = subclasses->at(i);
1855 Klass* k = ik->constants()->klass_at(cp_index, THREAD);
1856 if (HAS_PENDING_EXCEPTION) {
1857 if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) {
1858 return nullptr; // propagate VMEs
1859 }
1860 if (log_is_enabled(Trace, class, sealed)) {
1861 stringStream ss;
1862 char* permitted_subclass = ik->constants()->klass_name_at(cp_index)->as_C_string();
1863 ss.print(" - resolution of permitted subclass %s failed: ", permitted_subclass);
1864 java_lang_Throwable::print(PENDING_EXCEPTION, &ss);
1865 log_trace(class, sealed)("%s", ss.as_string());
1866 }
1867
1868 CLEAR_PENDING_EXCEPTION;
1869 continue;
1870 }
1871 if (k->is_instance_klass()) {
1950 constantTag tag = cp->tag_at(index);
1951 if (!tag.is_method() && !tag.is_interface_method()) {
1952 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
1953 }
1954 int klass_ref = cp->uncached_klass_ref_index_at(index);
1955 Klass* k_o;
1956 if (force_resolution) {
1957 k_o = cp->klass_at(klass_ref, CHECK_NULL);
1958 } else {
1959 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
1960 if (k_o == nullptr) return nullptr;
1961 }
1962 InstanceKlass* k = InstanceKlass::cast(k_o);
1963 Symbol* name = cp->uncached_name_ref_at(index);
1964 Symbol* sig = cp->uncached_signature_ref_at(index);
1965 methodHandle m (THREAD, k->find_method(name, sig));
1966 if (m.is_null()) {
1967 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
1968 }
1969 oop method;
1970 if (m->is_object_initializer()) {
1971 method = Reflection::new_constructor(m, CHECK_NULL);
1972 } else {
1973 // new_method accepts <clinit> as Method here
1974 method = Reflection::new_method(m, true, CHECK_NULL);
1975 }
1976 return JNIHandles::make_local(THREAD, method);
1977 }
1978
1979 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jint index))
1980 {
1981 JvmtiVMObjectAllocEventCollector oam;
1982 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1983 bounds_check(cp, index, CHECK_NULL);
1984 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
1985 return res;
1986 }
1987 JVM_END
1988
1989 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jint index))
1990 {
1991 JvmtiVMObjectAllocEventCollector oam;
1992 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1993 bounds_check(cp, index, CHECK_NULL);
2400
2401
2402 JVM_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
2403 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2404 Method* method = ik->methods()->at(method_index);
2405 return method->size_of_parameters();
2406 JVM_END
2407
2408
2409 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2410 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2411 Method* method = ik->methods()->at(method_index);
2412 return method->verifier_max_stack();
2413 JVM_END
2414
2415
2416 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2417 ResourceMark rm(THREAD);
2418 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2419 Method* method = ik->methods()->at(method_index);
2420 return method->name() == vmSymbols::object_initializer_name();
2421 JVM_END
2422
2423
2424 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2425 ResourceMark rm(THREAD);
2426 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2427 Method* method = ik->methods()->at(method_index);
2428 return method->is_overpass();
2429 JVM_END
2430
2431 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2432 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2433 Method* method = ik->methods()->at(method_index);
2434 return method->name()->as_utf8();
2435 JVM_END
2436
2437
2438 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
2439 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2440 Method* method = ik->methods()->at(method_index);
3190 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3191 void* find_result = os::dll_lookup(handle, name);
3192 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3193 find_result != nullptr ? "Found" : "Failed to find",
3194 name, p2i(handle));
3195 return find_result;
3196 JVM_END
3197
3198
3199 // JNI version ///////////////////////////////////////////////////////////////////////////////
3200
3201 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3202 return Threads::is_supported_jni_version_including_1_1(version);
3203 JVM_END
3204
3205
3206 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3207 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3208 JVM_END
3209
3210 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3211 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3212 JVM_END
3213
3214 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3215 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3216 JVM_END
3217
3218 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3219 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3220 JVM_END
3221
3222 // String support ///////////////////////////////////////////////////////////////////////////
3223
3224 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3225 JvmtiVMObjectAllocEventCollector oam;
3226 if (str == nullptr) return nullptr;
3227 oop string = JNIHandles::resolve_non_null(str);
3228 oop result = StringTable::intern(string, CHECK_NULL);
3229 return (jstring) JNIHandles::make_local(THREAD, result);
3269
3270 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3271 Handle loader, jboolean throwError, TRAPS) {
3272 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3273
3274 // Check if we should initialize the class
3275 if (init && klass->is_instance_klass()) {
3276 klass->initialize(CHECK_NULL);
3277 }
3278 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3279 }
3280
3281
3282 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3283
3284 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3285 Handle method_handle;
3286 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3287 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3288 Handle receiver(THREAD, JNIHandles::resolve(obj));
3289 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3290 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3291 jobject res = JNIHandles::make_local(THREAD, result);
3292 if (JvmtiExport::should_post_vm_object_alloc()) {
3293 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3294 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3295 if (java_lang_Class::is_primitive(ret_type)) {
3296 // Only for primitive type vm allocates memory for java object.
3297 // See box() method.
3298 JvmtiExport::post_vm_object_alloc(thread, result);
3299 }
3300 }
3301 return res;
3302 } else {
3303 THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3304 }
3305 JVM_END
3306
3307
3308 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3309 oop constructor_mirror = JNIHandles::resolve(c);
3310 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3311 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3312 jobject res = JNIHandles::make_local(THREAD, result);
3313 if (JvmtiExport::should_post_vm_object_alloc()) {
3314 JvmtiExport::post_vm_object_alloc(thread, result);
3315 }
3316 return res;
3317 JVM_END
3318
3319 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3320 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3321 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3322 JVM_END
3323
3324 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3325 jclass caller,
3326 jstring interfaceMethodName,
3327 jobject factoryType,
3328 jobject interfaceMethodType,
3329 jobject implementationMember,
3330 jobject dynamicMethodType,
3514 for (int i = 0; i < num_threads; i++) {
3515 Handle h = tle.get_threadObj(i);
3516 threads_ah->obj_at_put(i, h());
3517 }
3518
3519 return (jobjectArray) JNIHandles::make_local(THREAD, threads_ah());
3520 JVM_END
3521
3522
3523 // Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods
3524 // Return StackTraceElement[][], each element is the stack trace of a thread in
3525 // the corresponding entry in the given threads array
3526 JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads))
3527 JvmtiVMObjectAllocEventCollector oam;
3528
3529 // Check if threads is null
3530 if (threads == nullptr) {
3531 THROW_NULL(vmSymbols::java_lang_NullPointerException());
3532 }
3533
3534 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(threads));
3535 objArrayHandle ah(THREAD, a);
3536 int num_threads = ah->length();
3537 // check if threads is non-empty array
3538 if (num_threads == 0) {
3539 THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
3540 }
3541
3542 // check if threads is not an array of objects of Thread class
3543 Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass();
3544 if (k != vmClasses::Thread_klass()) {
3545 THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
3546 }
3547
3548 ResourceMark rm(THREAD);
3549
3550 GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads);
3551 for (int i = 0; i < num_threads; i++) {
3552 oop thread_obj = ah->obj_at(i);
3553 instanceHandle h(THREAD, (instanceOop) thread_obj);
3554 thread_handle_array->append(h);
3555 }
|
41 #include "classfile/modules.hpp"
42 #include "classfile/packageEntry.hpp"
43 #include "classfile/stringTable.hpp"
44 #include "classfile/symbolTable.hpp"
45 #include "classfile/systemDictionary.hpp"
46 #include "classfile/vmClasses.hpp"
47 #include "classfile/vmSymbols.hpp"
48 #include "gc/shared/collectedHeap.inline.hpp"
49 #include "interpreter/bytecode.hpp"
50 #include "interpreter/bytecodeUtils.hpp"
51 #include "jfr/jfrEvents.hpp"
52 #include "jvm.h"
53 #include "logging/log.hpp"
54 #include "memory/oopFactory.hpp"
55 #include "memory/referenceType.hpp"
56 #include "memory/resourceArea.hpp"
57 #include "memory/universe.hpp"
58 #include "oops/access.inline.hpp"
59 #include "oops/constantPool.hpp"
60 #include "oops/fieldStreams.inline.hpp"
61 #include "oops/flatArrayKlass.hpp"
62 #include "oops/inlineKlass.inline.hpp"
63 #include "oops/instanceKlass.hpp"
64 #include "oops/klass.inline.hpp"
65 #include "oops/method.hpp"
66 #include "oops/objArrayKlass.hpp"
67 #include "oops/objArrayOop.inline.hpp"
68 #include "oops/oop.inline.hpp"
69 #include "oops/oopCast.inline.hpp"
70 #include "oops/recordComponent.hpp"
71 #include "oops/refArrayOop.inline.hpp"
72 #include "oops/valuePayload.inline.hpp"
73 #include "prims/foreignGlobals.hpp"
74 #include "prims/jvm_misc.hpp"
75 #include "prims/jvmtiExport.hpp"
76 #include "prims/jvmtiThreadState.inline.hpp"
77 #include "prims/stackwalk.hpp"
78 #include "runtime/arguments.hpp"
79 #include "runtime/atomicAccess.hpp"
80 #include "runtime/continuation.hpp"
81 #include "runtime/deoptimization.hpp"
82 #include "runtime/globals_extension.hpp"
83 #include "runtime/handles.inline.hpp"
84 #include "runtime/handshake.hpp"
85 #include "runtime/init.hpp"
86 #include "runtime/interfaceSupport.inline.hpp"
87 #include "runtime/java.hpp"
88 #include "runtime/javaCalls.hpp"
89 #include "runtime/javaThread.hpp"
90 #include "runtime/jfieldIDWorkaround.hpp"
91 #include "runtime/jniHandles.inline.hpp"
92 #include "runtime/mountUnmountDisabler.hpp"
412
413 return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
414 JVM_END
415
416
417 /*
418 * Return the temporary directory that the VM uses for the attach
419 * and perf data files.
420 *
421 * It is important that this directory is well-known and the
422 * same for all VM instances. It cannot be affected by configuration
423 * variables such as java.io.tmpdir.
424 */
425 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
426 HandleMark hm(THREAD);
427 const char* temp_dir = os::get_temp_directory();
428 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
429 return (jstring) JNIHandles::make_local(THREAD, h());
430 JVM_END
431
432 static void validate_array_arguments(Klass* elmClass, jint len, TRAPS) {
433 if (len < 0) {
434 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Array length is negative");
435 }
436 elmClass->initialize(CHECK);
437 if (elmClass->is_array_klass() || elmClass->is_identity_class()) {
438 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not a value class");
439 }
440 if (elmClass->is_abstract()) {
441 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is abstract");
442 }
443 }
444
445 JVM_ENTRY(jarray, JVM_CopyOfSpecialArray(JNIEnv *env, jarray orig, jint from, jint to))
446 oop o = JNIHandles::resolve_non_null(orig);
447 assert(o->is_array(), "Must be");
448 oop array = nullptr;
449 arrayOop org = (arrayOop)o;
450 arrayHandle oh(THREAD, org);
451 ObjArrayKlass* ak = ObjArrayKlass::cast(org->klass());
452 InlineKlass* vk = InlineKlass::cast(ak->element_klass());
453 int len = to - from; // length of the new array
454 if (ak->is_null_free_array_klass()) {
455 if ((len != 0) && (from >= org->length() || to > org->length())) {
456 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Copying of null-free array with uninitialized elements");
457 }
458 }
459 if (ak->is_flatArray_klass()) {
460 // The whole JVM_CopyOfSpecialArray is currently broken. Fix this in a separate bugfix.
461 int org_length = org->length();
462 int copy_len = MIN2(to, org_length) - MIN2(from, org_length);
463 FlatArrayKlass* const fak = FlatArrayKlass::cast(org->klass());
464 flatArrayOop dst = oopFactory::new_flatArray(fak, len, CHECK_NULL);
465 assert(!ak->is_null_free_array_klass() || copy_len == len,
466 "Failed to throw the IllegalArgumentException");
467 if (copy_len != 0) {
468 int start = MIN2(from, org_length - 1);
469 FlatArrayPayload src_payload(flatArrayOop(oh()), start, fak);
470 FlatArrayPayload dst_payload(dst, 0, fak);
471 int end = to < oh()->length() ? to : oh()->length();
472 for (int i = from; i < end; i++) {
473 // Copy a value
474 src_payload.copy_to(dst_payload);
475
476 // Advance to the next element
477 src_payload.next_element();
478 dst_payload.next_element();
479 }
480 }
481 array = dst;
482 } else {
483 const ArrayProperties props = ArrayProperties::Default().with_null_restricted(ak->is_null_free_array_klass());
484
485 array = oopFactory::new_objArray(vk, len, props, CHECK_NULL);
486 int end = to < oh()->length() ? to : oh()->length();
487 for (int i = from; i < end; i++) {
488 if (i < ((objArrayOop)oh())->length()) {
489 oop val = ((objArrayOop)oh())->obj_at(i, CHECK_NULL);
490 ((objArrayOop)array)->obj_at_put(i - from, val);
491 } else {
492 assert(!ak->is_null_free_array_klass(), "Must be a nullable array");
493 ((objArrayOop)array)->obj_at_put(i - from, nullptr);
494 }
495 }
496 }
497 return (jarray) JNIHandles::make_local(THREAD, array);
498 JVM_END
499
500 JVM_ENTRY(jarray, JVM_NewNullRestrictedNonAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal))
501 oop mirror = JNIHandles::resolve_non_null(elmClass);
502 oop init = JNIHandles::resolve(initVal);
503 if (init == nullptr) {
504 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null");
505 }
506 Handle init_h(THREAD, init);
507 Klass* klass = java_lang_Class::as_Klass(mirror);
508 if (klass != init_h()->klass()) {
509 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value");
510 }
511 validate_array_arguments(klass, len, CHECK_NULL);
512 const ArrayProperties props = ArrayProperties::Default()
513 .with_null_restricted()
514 .with_non_atomic();
515
516 objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL);
517 for (int i = 0; i < len; i++) {
518 array->obj_at_put(i, init_h() /*, CHECK_NULL*/ );
519 }
520 return (jarray) JNIHandles::make_local(THREAD, array);
521 JVM_END
522
523 JVM_ENTRY(jarray, JVM_NewNullRestrictedAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal))
524 oop mirror = JNIHandles::resolve_non_null(elmClass);
525 oop init = JNIHandles::resolve(initVal);
526 if (init == nullptr) {
527 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null");
528 }
529 Handle init_h(THREAD, init);
530 Klass* klass = java_lang_Class::as_Klass(mirror);
531 if (klass != init_h()->klass()) {
532 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value");
533 }
534 validate_array_arguments(klass, len, CHECK_NULL);
535 const ArrayProperties props = ArrayProperties::Default().with_null_restricted();
536 objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL);
537 for (int i = 0; i < len; i++) {
538 array->obj_at_put(i, init_h() /*, CHECK_NULL*/ );
539 }
540 return (jarray) JNIHandles::make_local(THREAD, array);
541 JVM_END
542
543 JVM_ENTRY(jarray, JVM_NewNullableAtomicArray(JNIEnv *env, jclass elmClass, jint len))
544 oop mirror = JNIHandles::resolve_non_null(elmClass);
545 Klass* klass = java_lang_Class::as_Klass(mirror);
546 klass->initialize(CHECK_NULL);
547 validate_array_arguments(klass, len, CHECK_NULL);
548 objArrayOop array = oopFactory::new_objArray(klass, len, ArrayProperties::Default(), CHECK_NULL);
549 return (jarray) JNIHandles::make_local(THREAD, array);
550 JVM_END
551
552 JVM_ENTRY(jarray, JVM_NewReferenceArray(JNIEnv *env, jclass elmClass, jint len))
553 oop mirror = JNIHandles::resolve_non_null(elmClass);
554 Klass* klass = java_lang_Class::as_Klass(mirror);
555 validate_array_arguments(klass, len, CHECK_NULL);
556 refArrayOop array = oopFactory::new_refArray(klass, len, ArrayProperties::Default(), CHECK_NULL);
557 return (jarray) JNIHandles::make_local(THREAD, array);
558 JVM_END
559
560 JVM_ENTRY(jboolean, JVM_IsFlatArray(JNIEnv *env, jarray array))
561 oop o = JNIHandles::resolve_non_null(array);
562 Klass* klass = o->klass();
563
564 return klass->is_flatArray_klass();
565 JVM_END
566
567 JVM_ENTRY(jboolean, JVM_IsNullRestrictedArray(JNIEnv *env, jarray array))
568 oop o = JNIHandles::resolve_non_null(array);
569 Klass* klass = o->klass();
570
571 assert(klass->is_objArray_klass(), "Expects an object array");
572
573 return klass->is_null_free_array_klass();
574 JVM_END
575
576 JVM_ENTRY(jboolean, JVM_IsAtomicArray(JNIEnv *env, jarray array))
577 // There are multiple cases where an array can/must support atomic access:
578 // - the array is a reference array
579 // - the array uses an atomic flat layout: NULLABLE_ATOMIC_FLAT or NULL_FREE_ATOMIC_FLAT
580 // - the array is flat and its component type is naturally atomic
581 oop o = JNIHandles::resolve_non_null(array);
582 Klass* klass = o->klass();
583
584 assert(klass->is_objArray_klass(), "Expects an object array");
585
586 if (klass->is_refArray_klass()) {
587 return true;
588 }
589
590 if (klass->is_flatArray_klass()) {
591 FlatArrayKlass* fak = FlatArrayKlass::cast(klass);
592 if (LayoutKindHelper::is_atomic_flat(fak->layout_kind())) {
593 return true;
594 }
595 bool is_null_free = !LayoutKindHelper::is_nullable_flat(fak->layout_kind());
596 if (fak->element_klass()->is_naturally_atomic(is_null_free)) {
597 return true;
598 }
599
600 return false;
601 }
602
603 ShouldNotReachHere();
604 JVM_END
605
606 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
607
608 extern volatile jint vm_created;
609
610 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
611 EventShutdown event;
612 if (event.should_commit()) {
613 event.set_reason("Shutdown requested from Java");
614 event.commit();
615 }
616 JVM_END
617
618
619 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
620 before_exit(thread, true);
621 vm_exit(code);
622 JVM_END
623
624
702 }
703 if (method->is_native()) {
704 return nullptr;
705 }
706
707 stringStream ss;
708 bool ok = BytecodeUtils::get_NPE_message_at(&ss, method, bci);
709 if (ok) {
710 oop result = java_lang_String::create_oop_from_str(ss.base(), CHECK_NULL);
711 return (jstring) JNIHandles::make_local(THREAD, result);
712 } else {
713 return nullptr;
714 }
715 JVM_END
716
717 // java.lang.StackTraceElement //////////////////////////////////////////////
718
719
720 JVM_ENTRY(void, JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject backtrace, jint depth))
721 Handle backtraceh(THREAD, JNIHandles::resolve(backtrace));
722 refArrayOop st = refArrayOop(JNIHandles::resolve(elements));
723 refArrayHandle stack_trace(THREAD, st);
724 // Fill in the allocated stack trace
725 java_lang_Throwable::get_stack_trace_elements(depth, backtraceh, stack_trace, CHECK);
726 JVM_END
727
728
729 JVM_ENTRY(void, JVM_InitStackTraceElement(JNIEnv* env, jobject element, jobject stackFrameInfo))
730 Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(stackFrameInfo));
731 Handle stack_trace_element(THREAD, JNIHandles::resolve_non_null(element));
732 java_lang_StackFrameInfo::to_stack_trace_element(stack_frame_info, stack_trace_element, CHECK);
733 JVM_END
734
735
736 // java.lang.StackWalker //////////////////////////////////////////////////////
737 JVM_ENTRY(void, JVM_ExpandStackFrameInfo(JNIEnv *env, jobject obj))
738 Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(obj));
739
740 bool have_name = (java_lang_StackFrameInfo::name(stack_frame_info()) != nullptr);
741 bool have_type = (java_lang_StackFrameInfo::type(stack_frame_info()) != nullptr);
742 Method* method = java_lang_StackFrameInfo::get_method(stack_frame_info());
743 if (!have_name) {
746 }
747 if (!have_type) {
748 Handle type = java_lang_String::create_from_symbol(method->signature(), CHECK);
749 java_lang_StackFrameInfo::set_type(stack_frame_info(), type());
750 }
751 JVM_END
752
753 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode,
754 jint skip_frames, jobject contScope, jobject cont,
755 jint buffer_size, jint start_index, jobjectArray frames))
756 if (!thread->has_last_Java_frame()) {
757 THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", nullptr);
758 }
759
760 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
761 Handle contScope_h(THREAD, JNIHandles::resolve(contScope));
762 Handle cont_h(THREAD, JNIHandles::resolve(cont));
763 // frames array is a ClassFrameInfo[] array when only getting caller reference,
764 // and a StackFrameInfo[] array (or derivative) otherwise. It should never
765 // be null.
766 refArrayOop fa = refArrayOop(JNIHandles::resolve_non_null(frames));
767 refArrayHandle frames_array_h(THREAD, fa);
768
769 if (frames_array_h->length() < buffer_size) {
770 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", nullptr);
771 }
772
773 oop result = StackWalk::walk(stackStream_h, mode, skip_frames, contScope_h, cont_h,
774 buffer_size, start_index, frames_array_h, CHECK_NULL);
775 return JNIHandles::make_local(THREAD, result);
776 JVM_END
777
778
779 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor,
780 jint last_batch_count, jint buffer_size, jint start_index,
781 jobjectArray frames))
782 // frames array is a ClassFrameInfo[] array when only getting caller reference,
783 // and a StackFrameInfo[] array (or derivative) otherwise. It should never
784 // be null.
785 refArrayOop fa = refArrayOop(JNIHandles::resolve_non_null(frames));
786 refArrayHandle frames_array_h(THREAD, fa);
787
788 if (frames_array_h->length() < buffer_size) {
789 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");
790 }
791
792 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
793 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
794 start_index, frames_array_h, THREAD);
795 JVM_END
796
797 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
798 refArrayOop fa = refArrayOop(JNIHandles::resolve_non_null(frames));
799 refArrayHandle frames_array_h(THREAD, fa);
800 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
801 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
802
803 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
804 JVM_END
805
806 // java.lang.Object ///////////////////////////////////////////////
807
808
809 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
810 // as implemented in the classic virtual machine; return 0 if object is null
811 if (handle == nullptr) {
812 return 0;
813 }
814 oop obj = JNIHandles::resolve_non_null(handle);
815 if (Arguments::is_valhalla_enabled() && obj->klass()->is_inline_klass()) {
816 const intptr_t obj_identity_hash = obj->mark().hash();
817 // Check if mark word contains hash code already.
818 // It is possible that the generated identity hash is 0, which is not
819 // distinct from the no_hash value. In such a case, the hash will be
820 // computed and set every time JVM_IHashCode is called. If that happens,
821 // the only consequence is losing out on the optimization.
822 if (obj_identity_hash != markWord::no_hash) {
823 return checked_cast<jint>(obj_identity_hash);
824 }
825
826 // Compute hash by calling ValueObjectMethods.valueObjectHashCode.
827 // The identity hash is invariantly immutable (see its JavaDoc comment).
828 JavaValue result(T_INT);
829 JavaCallArguments args;
830 Handle ho(THREAD, obj);
831 args.push_oop(ho);
832 methodHandle method(THREAD, Universe::value_object_hash_code_method());
833 JavaCalls::call(&result, method, &args, THREAD);
834 if (HAS_PENDING_EXCEPTION) {
835 if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
836 Handle e(THREAD, PENDING_EXCEPTION);
837 CLEAR_PENDING_EXCEPTION;
838 THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
839 }
840 }
841 const intptr_t identity_hash = result.get_jint();
842
843 // We now have to set the hash via CAS. It's possible that this will race
844 // other threads. By our invariant of immutability, when there is a
845 // race, the identity hash code is going to be one of the following:
846 // a) 0, another thread updated other markWord bits; b) identity_hash set
847 // by another thread; or c) identity_hash set by the current thread.
848 // A nonzero identity hash code that is not the identity_hash computed
849 // earlier indicates a violation of the invariant.
850 markWord current_mark, old_mark, new_mark;
851 do {
852 current_mark = ho->mark();
853 new_mark = current_mark.copy_set_hash(identity_hash);
854 old_mark = ho->cas_set_mark(new_mark, current_mark);
855 assert(old_mark.has_no_hash() || old_mark.hash() == new_mark.hash(),
856 "CAS identity hash invariant violated, expected=" INTPTR_FORMAT " actual=" INTPTR_FORMAT,
857 new_mark.hash(),
858 old_mark.hash());
859 } while (old_mark != current_mark);
860
861 return checked_cast<jint>(new_mark.hash());
862 } else {
863 return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj));
864 }
865 JVM_END
866
867
868 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
869 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
870 ObjectSynchronizer::wait(obj, ms, CHECK);
871 JVM_END
872
873
874 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
875 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
876 ObjectSynchronizer::notify(obj, CHECK);
877 JVM_END
878
879
880 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
881 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
882 ObjectSynchronizer::notifyall(obj, CHECK);
883 JVM_END
884
892 // Just checking that the cloneable flag is set correct
893 if (obj->is_array()) {
894 guarantee(klass->is_cloneable(), "all arrays are cloneable");
895 } else {
896 guarantee(obj->is_instance(), "should be instanceOop");
897 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
898 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
899 }
900 #endif
901
902 // Check if class of obj supports the Cloneable interface.
903 // All arrays are considered to be cloneable (See JLS 20.1.5).
904 // All j.l.r.Reference classes are considered non-cloneable.
905 if (!klass->is_cloneable() ||
906 (klass->is_instance_klass() &&
907 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
908 ResourceMark rm(THREAD);
909 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
910 }
911
912 if (klass->is_inline_klass()) {
913 // Value instances have no identity, so return the current instance instead of allocating a new one
914 // Value classes cannot have finalizers, so the method can return immediately
915 return JNIHandles::make_local(THREAD, obj());
916 }
917
918 // Make shallow object copy
919 const size_t size = obj->size();
920 oop new_obj_oop = nullptr;
921 if (obj->is_array()) {
922 const int length = ((arrayOop)obj())->length();
923 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
924 /* do_zero */ true, CHECK_NULL);
925 } else {
926 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
927 }
928
929 HeapAccess<>::clone(obj(), new_obj_oop, size);
930
931 Handle new_obj(THREAD, new_obj_oop);
932 // Caution: this involves a java upcall, so the clone should be
933 // "gc-robust" by this stage.
934 if (klass->has_finalizer()) {
935 assert(obj->is_instance(), "should be instanceOop");
936 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
937 new_obj = Handle(THREAD, new_obj_oop);
1390 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1391 return (jstring) JNIHandles::make_local(THREAD, result);
1392 JVM_END
1393
1394
1395 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1396 JvmtiVMObjectAllocEventCollector oam;
1397 oop mirror = JNIHandles::resolve_non_null(cls);
1398
1399 // Special handling for primitive objects
1400 if (java_lang_Class::is_primitive(mirror)) {
1401 // Primitive objects does not have any interfaces
1402 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1403 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1404 }
1405
1406 Klass* klass = java_lang_Class::as_Klass(mirror);
1407 // Figure size of result array
1408 int size;
1409 if (klass->is_instance_klass()) {
1410 InstanceKlass* ik = InstanceKlass::cast(klass);
1411 size = ik->local_interfaces()->length();
1412 } else {
1413 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1414 size = 2;
1415 }
1416
1417 // Allocate result array
1418 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1419 objArrayHandle result (THREAD, r);
1420 // Fill in result
1421 if (klass->is_instance_klass()) {
1422 // Regular instance klass, fill in all local interfaces
1423 for (int index = 0; index < size; index++) {
1424 InstanceKlass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1425 result->obj_at_put(index, k->java_mirror());
1426 }
1427 } else {
1428 // All arrays implement java.lang.Cloneable and java.io.Serializable
1429 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1430 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1431 }
1479
1480 return nullptr;
1481 JVM_END
1482
1483 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
1484 JvmtiVMObjectAllocEventCollector oam;
1485 // ofClass is a reference to a java_lang_Class object. The mirror object
1486 // of an InstanceKlass
1487 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1488 if (java_lang_Class::is_primitive(ofMirror) ||
1489 ! java_lang_Class::as_Klass(ofMirror)->is_instance_klass()) {
1490 oop result = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1491 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1492 }
1493
1494 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1495 InnerClassesIterator iter(k);
1496
1497 if (iter.length() == 0) {
1498 // Neither an inner nor outer class
1499 oop result = oopFactory::new_refArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1500 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1501 }
1502
1503 // find inner class info
1504 constantPoolHandle cp(thread, k->constants());
1505 int length = iter.length();
1506
1507 // Allocate temp. result array
1508 refArrayOop r = oopFactory::new_refArray(vmClasses::Class_klass(), length / 4, CHECK_NULL);
1509 refArrayHandle result(THREAD, r);
1510 int members = 0;
1511
1512 for (; !iter.done(); iter.next()) {
1513 int ioff = iter.inner_class_info_index();
1514 int ooff = iter.outer_class_info_index();
1515
1516 if (ioff != 0 && ooff != 0) {
1517 // Check to see if the name matches the class we're looking for
1518 // before attempting to find the class.
1519 if (cp->klass_name_at_matches(k, ooff)) {
1520 Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL);
1521 if (outer_klass == k) {
1522 Klass* ik = cp->klass_at(ioff, CHECK_NULL);
1523 InstanceKlass* inner_klass = InstanceKlass::cast(ik);
1524
1525 // Throws an exception if outer klass has not declared k as
1526 // an inner klass
1527 Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);
1528
1529 result->obj_at_put(members, inner_klass->java_mirror());
1530 members++;
1531 }
1532 }
1533 }
1534 }
1535
1536 if (members != length) {
1537 // Return array of right length
1538 refArrayOop res = oopFactory::new_refArray(vmClasses::Class_klass(), members, CHECK_NULL);
1539 for(int i = 0; i < members; i++) {
1540 res->obj_at_put(i, result->obj_at(i));
1541 }
1542 return (jobjectArray)JNIHandles::make_local(THREAD, res);
1543 }
1544
1545 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1546 JVM_END
1547
1548
1549 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1550 {
1551 // ofClass is a reference to a java_lang_Class object.
1552 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1553 if (java_lang_Class::is_primitive(ofMirror)) {
1554 return nullptr;
1555 }
1556 Klass* klass = java_lang_Class::as_Klass(ofMirror);
1557 if (!klass->is_instance_klass()) {
1558 return nullptr;
1895 }
1896
1897 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1898
1899 // Ensure class is linked
1900 k->link_class(CHECK_NULL);
1901
1902 Array<Method*>* methods = k->methods();
1903 int methods_length = methods->length();
1904
1905 // Save original method_idnum in case of redefinition, which can change
1906 // the idnum of obsolete methods. The new method will have the same idnum
1907 // but if we refresh the methods array, the counts will be wrong.
1908 ResourceMark rm(THREAD);
1909 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1910 int num_methods = 0;
1911
1912 // Select methods matching the criteria.
1913 for (int i = 0; i < methods_length; i++) {
1914 Method* method = methods->at(i);
1915 if (want_constructor && !method->is_object_constructor()) {
1916 continue;
1917 }
1918 if (!want_constructor &&
1919 (method->is_object_constructor() || method->is_class_initializer() ||
1920 method->is_overpass())) {
1921 continue;
1922 }
1923 if (publicOnly && !method->is_public()) {
1924 continue;
1925 }
1926 idnums->push(method->method_idnum());
1927 ++num_methods;
1928 }
1929
1930 // Allocate result
1931 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1932 objArrayHandle result (THREAD, r);
1933
1934 // Now just put the methods that we selected above, but go by their idnum
1935 // in case of redefinition. The methods can be redefined at any safepoint,
1936 // so above when allocating the oop array and below when creating reflect
1937 // objects.
1938 for (int i = 0; i < num_methods; i++) {
1939 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1940 if (method.is_null()) {
1941 // Method may have been deleted and seems this API can handle null
1942 // Otherwise should probably put a method that throws NSME
1943 result->obj_at_put(i, nullptr);
1944 } else {
1945 oop m;
1946 if (want_constructor) {
1947 assert(method->is_object_constructor(), "must be");
1948 m = Reflection::new_constructor(method, CHECK_NULL);
1949 } else {
1950 m = Reflection::new_method(method, false, CHECK_NULL);
1951 }
1952 result->obj_at_put(i, m);
1953 }
1954 }
1955
1956 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1957 }
1958
1959 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1960 {
1961 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1962 /*want_constructor*/ false,
1963 vmClasses::reflect_Method_klass(), THREAD);
1964 }
1965 JVM_END
1966
1967 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1990 }
1991 JVM_END
1992
1993 JVM_ENTRY(jobjectArray, JVM_GetNestMembers(JNIEnv* env, jclass current))
1994 {
1995 // current is not a primitive or array class
1996 ResourceMark rm(THREAD);
1997 InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
1998 InstanceKlass* host = c->nest_host(THREAD);
1999
2000 log_trace(class, nestmates)("Calling GetNestMembers for type %s with nest-host %s",
2001 c->external_name(), host->external_name());
2002 {
2003 JvmtiVMObjectAllocEventCollector oam;
2004 Array<u2>* members = host->nest_members();
2005 int length = members == nullptr ? 0 : members->length();
2006
2007 log_trace(class, nestmates)(" - host has %d listed nest members", length);
2008
2009 // nest host is first in the array so make it one bigger
2010 refArrayOop r = oopFactory::new_refArray(vmClasses::Class_klass(), length + 1, CHECK_NULL);
2011 refArrayHandle result(THREAD, r);
2012 result->obj_at_put(0, host->java_mirror());
2013 if (length != 0) {
2014 int count = 0;
2015 for (int i = 0; i < length; i++) {
2016 int cp_index = members->at(i);
2017 Klass* k = host->constants()->klass_at(cp_index, THREAD);
2018 if (HAS_PENDING_EXCEPTION) {
2019 if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) {
2020 return nullptr; // propagate VMEs
2021 }
2022 if (log_is_enabled(Trace, class, nestmates)) {
2023 stringStream ss;
2024 char* target_member_class = host->constants()->klass_name_at(cp_index)->as_C_string();
2025 ss.print(" - resolution of nest member %s failed: ", target_member_class);
2026 java_lang_Throwable::print(PENDING_EXCEPTION, &ss);
2027 log_trace(class, nestmates)("%s", ss.as_string());
2028 }
2029 CLEAR_PENDING_EXCEPTION;
2030 continue;
2031 }
2066 }
2067 }
2068 JVM_END
2069
2070 JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current))
2071 {
2072 oop mirror = JNIHandles::resolve_non_null(current);
2073 assert(!java_lang_Class::is_primitive(mirror), "should not be");
2074 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
2075
2076 ResourceMark rm(THREAD);
2077 log_trace(class, sealed)("Calling GetPermittedSubclasses for %s type %s",
2078 ik->is_sealed() ? "sealed" : "non-sealed", ik->external_name());
2079 if (ik->is_sealed()) {
2080 JvmtiVMObjectAllocEventCollector oam;
2081 Array<u2>* subclasses = ik->permitted_subclasses();
2082 int length = subclasses->length();
2083
2084 log_trace(class, sealed)(" - sealed class has %d permitted subclasses", length);
2085
2086 refArrayOop r = oopFactory::new_refArray(vmClasses::Class_klass(), length, CHECK_NULL);
2087 refArrayHandle result(THREAD, r);
2088 int count = 0;
2089 for (int i = 0; i < length; i++) {
2090 int cp_index = subclasses->at(i);
2091 Klass* k = ik->constants()->klass_at(cp_index, THREAD);
2092 if (HAS_PENDING_EXCEPTION) {
2093 if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) {
2094 return nullptr; // propagate VMEs
2095 }
2096 if (log_is_enabled(Trace, class, sealed)) {
2097 stringStream ss;
2098 char* permitted_subclass = ik->constants()->klass_name_at(cp_index)->as_C_string();
2099 ss.print(" - resolution of permitted subclass %s failed: ", permitted_subclass);
2100 java_lang_Throwable::print(PENDING_EXCEPTION, &ss);
2101 log_trace(class, sealed)("%s", ss.as_string());
2102 }
2103
2104 CLEAR_PENDING_EXCEPTION;
2105 continue;
2106 }
2107 if (k->is_instance_klass()) {
2186 constantTag tag = cp->tag_at(index);
2187 if (!tag.is_method() && !tag.is_interface_method()) {
2188 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2189 }
2190 int klass_ref = cp->uncached_klass_ref_index_at(index);
2191 Klass* k_o;
2192 if (force_resolution) {
2193 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2194 } else {
2195 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2196 if (k_o == nullptr) return nullptr;
2197 }
2198 InstanceKlass* k = InstanceKlass::cast(k_o);
2199 Symbol* name = cp->uncached_name_ref_at(index);
2200 Symbol* sig = cp->uncached_signature_ref_at(index);
2201 methodHandle m (THREAD, k->find_method(name, sig));
2202 if (m.is_null()) {
2203 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2204 }
2205 oop method;
2206 if (m->is_object_constructor()) {
2207 method = Reflection::new_constructor(m, CHECK_NULL);
2208 } else {
2209 method = Reflection::new_method(m, true, CHECK_NULL);
2210 }
2211 return JNIHandles::make_local(THREAD, method);
2212 }
2213
2214 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jint index))
2215 {
2216 JvmtiVMObjectAllocEventCollector oam;
2217 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2218 bounds_check(cp, index, CHECK_NULL);
2219 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2220 return res;
2221 }
2222 JVM_END
2223
2224 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jint index))
2225 {
2226 JvmtiVMObjectAllocEventCollector oam;
2227 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2228 bounds_check(cp, index, CHECK_NULL);
2635
2636
2637 JVM_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
2638 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2639 Method* method = ik->methods()->at(method_index);
2640 return method->size_of_parameters();
2641 JVM_END
2642
2643
2644 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2645 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2646 Method* method = ik->methods()->at(method_index);
2647 return method->verifier_max_stack();
2648 JVM_END
2649
2650
2651 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2652 ResourceMark rm(THREAD);
2653 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2654 Method* method = ik->methods()->at(method_index);
2655 return method->is_object_constructor();
2656 JVM_END
2657
2658
2659 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2660 ResourceMark rm(THREAD);
2661 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2662 Method* method = ik->methods()->at(method_index);
2663 return method->is_overpass();
2664 JVM_END
2665
2666 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2667 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2668 Method* method = ik->methods()->at(method_index);
2669 return method->name()->as_utf8();
2670 JVM_END
2671
2672
2673 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
2674 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2675 Method* method = ik->methods()->at(method_index);
3425 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3426 void* find_result = os::dll_lookup(handle, name);
3427 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3428 find_result != nullptr ? "Found" : "Failed to find",
3429 name, p2i(handle));
3430 return find_result;
3431 JVM_END
3432
3433
3434 // JNI version ///////////////////////////////////////////////////////////////////////////////
3435
3436 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3437 return Threads::is_supported_jni_version_including_1_1(version);
3438 JVM_END
3439
3440
3441 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3442 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3443 JVM_END
3444
3445 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3446 return Arguments::is_valhalla_enabled() ? JNI_TRUE : JNI_FALSE;
3447 JVM_END
3448
3449 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3450 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3451 JVM_END
3452
3453 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3454 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3455 JVM_END
3456
3457 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3458 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3459 JVM_END
3460
3461 // String support ///////////////////////////////////////////////////////////////////////////
3462
3463 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3464 JvmtiVMObjectAllocEventCollector oam;
3465 if (str == nullptr) return nullptr;
3466 oop string = JNIHandles::resolve_non_null(str);
3467 oop result = StringTable::intern(string, CHECK_NULL);
3468 return (jstring) JNIHandles::make_local(THREAD, result);
3508
3509 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3510 Handle loader, jboolean throwError, TRAPS) {
3511 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3512
3513 // Check if we should initialize the class
3514 if (init && klass->is_instance_klass()) {
3515 klass->initialize(CHECK_NULL);
3516 }
3517 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3518 }
3519
3520
3521 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3522
3523 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3524 Handle method_handle;
3525 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3526 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3527 Handle receiver(THREAD, JNIHandles::resolve(obj));
3528 objArrayHandle args(THREAD, (objArrayOop)JNIHandles::resolve(args0));
3529 assert(args() == nullptr || !args->is_flatArray(), "args are never flat or are they???");
3530
3531 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3532 jobject res = JNIHandles::make_local(THREAD, result);
3533 if (JvmtiExport::should_post_vm_object_alloc()) {
3534 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3535 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3536 if (java_lang_Class::is_primitive(ret_type)) {
3537 // Only for primitive type vm allocates memory for java object.
3538 // See box() method.
3539 JvmtiExport::post_vm_object_alloc(thread, result);
3540 }
3541 }
3542 return res;
3543 } else {
3544 THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3545 }
3546 JVM_END
3547
3548
3549 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3550 objArrayHandle args(THREAD, (objArrayOop)JNIHandles::resolve(args0));
3551 assert(args() == nullptr || !args->is_flatArray(), "args are never flat or are they???");
3552 oop constructor_mirror = JNIHandles::resolve(c);
3553 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3554 jobject res = JNIHandles::make_local(THREAD, result);
3555 if (JvmtiExport::should_post_vm_object_alloc()) {
3556 JvmtiExport::post_vm_object_alloc(thread, result);
3557 }
3558 return res;
3559 JVM_END
3560
3561 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3562 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3563 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3564 JVM_END
3565
3566 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3567 jclass caller,
3568 jstring interfaceMethodName,
3569 jobject factoryType,
3570 jobject interfaceMethodType,
3571 jobject implementationMember,
3572 jobject dynamicMethodType,
3756 for (int i = 0; i < num_threads; i++) {
3757 Handle h = tle.get_threadObj(i);
3758 threads_ah->obj_at_put(i, h());
3759 }
3760
3761 return (jobjectArray) JNIHandles::make_local(THREAD, threads_ah());
3762 JVM_END
3763
3764
3765 // Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods
3766 // Return StackTraceElement[][], each element is the stack trace of a thread in
3767 // the corresponding entry in the given threads array
3768 JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads))
3769 JvmtiVMObjectAllocEventCollector oam;
3770
3771 // Check if threads is null
3772 if (threads == nullptr) {
3773 THROW_NULL(vmSymbols::java_lang_NullPointerException());
3774 }
3775
3776 refArrayOop a = oop_cast<refArrayOop>(JNIHandles::resolve_non_null(threads));
3777 refArrayHandle ah(THREAD, a);
3778 int num_threads = ah->length();
3779 // check if threads is non-empty array
3780 if (num_threads == 0) {
3781 THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
3782 }
3783
3784 // check if threads is not an array of objects of Thread class
3785 Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass();
3786 if (k != vmClasses::Thread_klass()) {
3787 THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
3788 }
3789
3790 ResourceMark rm(THREAD);
3791
3792 GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads);
3793 for (int i = 0; i < num_threads; i++) {
3794 oop thread_obj = ah->obj_at(i);
3795 instanceHandle h(THREAD, (instanceOop) thread_obj);
3796 thread_handle_array->append(h);
3797 }
|