39 #include "classfile/modules.hpp"
40 #include "classfile/packageEntry.hpp"
41 #include "classfile/stringTable.hpp"
42 #include "classfile/symbolTable.hpp"
43 #include "classfile/systemDictionary.hpp"
44 #include "classfile/vmClasses.hpp"
45 #include "classfile/vmSymbols.hpp"
46 #include "gc/shared/collectedHeap.inline.hpp"
47 #include "interpreter/bytecode.hpp"
48 #include "interpreter/bytecodeUtils.hpp"
49 #include "jfr/jfrEvents.hpp"
50 #include "jvm.h"
51 #include "logging/log.hpp"
52 #include "memory/oopFactory.hpp"
53 #include "memory/referenceType.hpp"
54 #include "memory/resourceArea.hpp"
55 #include "memory/universe.hpp"
56 #include "oops/access.inline.hpp"
57 #include "oops/constantPool.hpp"
58 #include "oops/fieldStreams.inline.hpp"
59 #include "oops/instanceKlass.hpp"
60 #include "oops/klass.inline.hpp"
61 #include "oops/method.hpp"
62 #include "oops/recordComponent.hpp"
63 #include "oops/objArrayKlass.hpp"
64 #include "oops/objArrayOop.inline.hpp"
65 #include "oops/oop.inline.hpp"
66 #include "prims/foreignGlobals.hpp"
67 #include "prims/jvm_misc.hpp"
68 #include "prims/jvmtiExport.hpp"
69 #include "prims/jvmtiThreadState.inline.hpp"
70 #include "prims/stackwalk.hpp"
71 #include "runtime/arguments.hpp"
72 #include "runtime/atomic.hpp"
73 #include "runtime/continuation.hpp"
74 #include "runtime/globals_extension.hpp"
75 #include "runtime/handles.inline.hpp"
76 #include "runtime/init.hpp"
77 #include "runtime/interfaceSupport.inline.hpp"
78 #include "runtime/deoptimization.hpp"
590 }
591
592 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
593 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
594 start_index, frames_array_h, THREAD);
595 JVM_END
596
597 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
598 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
599 objArrayHandle frames_array_h(THREAD, fa);
600 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
601 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
602
603 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
604 JVM_END
605
606 // java.lang.Object ///////////////////////////////////////////////
607
608
609 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
610 // as implemented in the classic virtual machine; return 0 if object is null
611 return handle == nullptr ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;
612 JVM_END
613
614
615 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
616 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
617 JavaThreadInObjectWaitState jtiows(thread, ms != 0);
618 if (JvmtiExport::should_post_monitor_wait()) {
619 JvmtiExport::post_monitor_wait(thread, obj(), ms);
620
621 // The current thread already owns the monitor and it has not yet
622 // been added to the wait queue so the current thread cannot be
623 // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
624 // event handler cannot accidentally consume an unpark() meant for
625 // the ParkEvent associated with this ObjectMonitor.
626 }
627 ObjectSynchronizer::wait(obj, ms, CHECK);
628 JVM_END
629
630
631 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
643 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
644 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
645 Klass* klass = obj->klass();
646 JvmtiVMObjectAllocEventCollector oam;
647
648 #ifdef ASSERT
649 // Just checking that the cloneable flag is set correct
650 if (obj->is_array()) {
651 guarantee(klass->is_cloneable(), "all arrays are cloneable");
652 } else {
653 guarantee(obj->is_instance(), "should be instanceOop");
654 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
655 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
656 }
657 #endif
658
659 // Check if class of obj supports the Cloneable interface.
660 // All arrays are considered to be cloneable (See JLS 20.1.5).
661 // All j.l.r.Reference classes are considered non-cloneable.
662 if (!klass->is_cloneable() ||
663 (klass->is_instance_klass() &&
664 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
665 ResourceMark rm(THREAD);
666 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
667 }
668
669 // Make shallow object copy
670 const size_t size = obj->size();
671 oop new_obj_oop = nullptr;
672 if (obj->is_array()) {
673 const int length = ((arrayOop)obj())->length();
674 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
675 /* do_zero */ true, CHECK_NULL);
676 } else {
677 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
678 }
679
680 HeapAccess<>::clone(obj(), new_obj_oop, size);
681
682 Handle new_obj(THREAD, new_obj_oop);
1156 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1157 return (jstring) JNIHandles::make_local(THREAD, result);
1158 JVM_END
1159
1160
1161 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1162 JvmtiVMObjectAllocEventCollector oam;
1163 oop mirror = JNIHandles::resolve_non_null(cls);
1164
1165 // Special handling for primitive objects
1166 if (java_lang_Class::is_primitive(mirror)) {
1167 // Primitive objects does not have any interfaces
1168 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1169 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1170 }
1171
1172 Klass* klass = java_lang_Class::as_Klass(mirror);
1173 // Figure size of result array
1174 int size;
1175 if (klass->is_instance_klass()) {
1176 size = InstanceKlass::cast(klass)->local_interfaces()->length();
1177 } else {
1178 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1179 size = 2;
1180 }
1181
1182 // Allocate result array
1183 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1184 objArrayHandle result (THREAD, r);
1185 // Fill in result
1186 if (klass->is_instance_klass()) {
1187 // Regular instance klass, fill in all local interfaces
1188 for (int index = 0; index < size; index++) {
1189 Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1190 result->obj_at_put(index, k->java_mirror());
1191 }
1192 } else {
1193 // All arrays implement java.lang.Cloneable and java.io.Serializable
1194 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1195 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1196 }
1197 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1198 JVM_END
1199
1200
1201 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1202 oop mirror = JNIHandles::resolve_non_null(cls);
1203 if (java_lang_Class::is_primitive(mirror)) {
1204 return JNI_FALSE;
1205 }
1206 Klass* k = java_lang_Class::as_Klass(mirror);
1207 jboolean result = k->is_interface();
1208 assert(!result || k->is_instance_klass(),
1209 "all interfaces are instance types");
1210 // The compiler intrinsic for isInterface tests the
1211 // Klass::_access_flags bits in the same way.
1212 return result;
1213 JVM_END
1214
1215 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1216 oop mirror = JNIHandles::resolve_non_null(cls);
1217 if (java_lang_Class::is_primitive(mirror)) {
1218 return JNI_FALSE;
1219 }
1220 Klass* k = java_lang_Class::as_Klass(mirror);
1221 return k->is_hidden();
1222 JVM_END
1223
1224 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1225 JvmtiVMObjectAllocEventCollector oam;
1226 oop mirror = JNIHandles::resolve_non_null(cls);
1227 if (java_lang_Class::is_primitive(mirror)) {
1228 // There are no signers for primitive types
1229 return nullptr;
1230 }
1231
1232 objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1233
1234 // If there are no signers set in the class, or if the class
1235 // is an array, return null.
1236 if (signers == nullptr) return nullptr;
1237
1238 // copy of the signers array
1239 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1240 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1241 for (int index = 0; index < signers->length(); index++) {
1242 signers_copy->obj_at_put(index, signers->obj_at(index));
1243 }
1819 int length = components->length();
1820 assert(length >= 0, "unexpected record_components length");
1821 objArrayOop record_components =
1822 oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1823 objArrayHandle components_h (THREAD, record_components);
1824
1825 for (int x = 0; x < length; x++) {
1826 RecordComponent* component = components->at(x);
1827 assert(component != nullptr, "unexpected null record component");
1828 oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1829 components_h->obj_at_put(x, component_oop);
1830 }
1831 return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1832 }
1833
1834 return nullptr;
1835 }
1836 JVM_END
1837
1838 static bool select_method(const methodHandle& method, bool want_constructor) {
1839 if (want_constructor) {
1840 return (method->is_initializer() && !method->is_static());
1841 } else {
1842 return (!method->is_initializer() && !method->is_overpass());
1843 }
1844 }
1845
1846 static jobjectArray get_class_declared_methods_helper(
1847 JNIEnv *env,
1848 jclass ofClass, jboolean publicOnly,
1849 bool want_constructor,
1850 Klass* klass, TRAPS) {
1851
1852 JvmtiVMObjectAllocEventCollector oam;
1853
1854 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1855 // Exclude primitive types and array types
1856 if (java_lang_Class::is_primitive(ofMirror)
1857 || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1858 // Return empty array
1859 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1860 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1861 }
1862
1885 }
1886 }
1887
1888 // Allocate result
1889 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1890 objArrayHandle result (THREAD, r);
1891
1892 // Now just put the methods that we selected above, but go by their idnum
1893 // in case of redefinition. The methods can be redefined at any safepoint,
1894 // so above when allocating the oop array and below when creating reflect
1895 // objects.
1896 for (int i = 0; i < num_methods; i++) {
1897 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1898 if (method.is_null()) {
1899 // Method may have been deleted and seems this API can handle null
1900 // Otherwise should probably put a method that throws NSME
1901 result->obj_at_put(i, nullptr);
1902 } else {
1903 oop m;
1904 if (want_constructor) {
1905 m = Reflection::new_constructor(method, CHECK_NULL);
1906 } else {
1907 m = Reflection::new_method(method, false, CHECK_NULL);
1908 }
1909 result->obj_at_put(i, m);
1910 }
1911 }
1912
1913 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1914 }
1915
1916 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1917 {
1918 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1919 /*want_constructor*/ false,
1920 vmClasses::reflect_Method_klass(), THREAD);
1921 }
1922 JVM_END
1923
1924 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
2167 constantTag tag = cp->tag_at(index);
2168 if (!tag.is_method() && !tag.is_interface_method()) {
2169 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2170 }
2171 int klass_ref = cp->uncached_klass_ref_index_at(index);
2172 Klass* k_o;
2173 if (force_resolution) {
2174 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2175 } else {
2176 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2177 if (k_o == nullptr) return nullptr;
2178 }
2179 InstanceKlass* k = InstanceKlass::cast(k_o);
2180 Symbol* name = cp->uncached_name_ref_at(index);
2181 Symbol* sig = cp->uncached_signature_ref_at(index);
2182 methodHandle m (THREAD, k->find_method(name, sig));
2183 if (m.is_null()) {
2184 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2185 }
2186 oop method;
2187 if (!m->is_initializer() || m->is_static()) {
2188 method = Reflection::new_method(m, true, CHECK_NULL);
2189 } else {
2190 method = Reflection::new_constructor(m, CHECK_NULL);
2191 }
2192 return JNIHandles::make_local(THREAD, method);
2193 }
2194
2195 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2196 {
2197 JvmtiVMObjectAllocEventCollector oam;
2198 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2199 bounds_check(cp, index, CHECK_NULL);
2200 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2201 return res;
2202 }
2203 JVM_END
2204
2205 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2206 {
2207 JvmtiVMObjectAllocEventCollector oam;
2208 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2209 bounds_check(cp, index, CHECK_NULL);
2210 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
2441 Klass* k = java_lang_Class::as_Klass(r);
2442 assert(k->is_instance_klass(), "must be an instance klass");
2443 if (!k->is_instance_klass()) return false;
2444
2445 ResourceMark rm(THREAD);
2446 const char* name = k->name()->as_C_string();
2447 bool system_class = k->class_loader() == nullptr;
2448 return JavaAssertions::enabled(name, system_class);
2449
2450 JVM_END
2451
2452
2453 // Return a new AssertionStatusDirectives object with the fields filled in with
2454 // command-line assertion arguments (i.e., -ea, -da).
2455 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2456 JvmtiVMObjectAllocEventCollector oam;
2457 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2458 return JNIHandles::make_local(THREAD, asd);
2459 JVM_END
2460
2461 // Verification ////////////////////////////////////////////////////////////////////////////////
2462
2463 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2464
2465 // RedefineClasses support: bug 6214132 caused verification to fail.
2466 // All functions from this section should call the jvmtiThreadSate function:
2467 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2468 // The function returns a Klass* of the _scratch_class if the verifier
2469 // was invoked in the middle of the class redefinition.
2470 // Otherwise it returns its argument value which is the _the_class Klass*.
2471 // Please, refer to the description in the jvmtiThreadSate.hpp.
2472
2473 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2474 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2475 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2476 return k->name()->as_utf8();
2477 JVM_END
2478
2479
2480 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
2603 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2604 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2605 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2606 return method->size_of_parameters();
2607 JVM_END
2608
2609
2610 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2611 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2612 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2613 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2614 return method->verifier_max_stack();
2615 JVM_END
2616
2617
2618 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2619 ResourceMark rm(THREAD);
2620 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2621 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2622 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2623 return method->name() == vmSymbols::object_initializer_name();
2624 JVM_END
2625
2626
2627 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2628 ResourceMark rm(THREAD);
2629 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2630 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2631 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2632 return method->is_overpass();
2633 JVM_END
2634
2635 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2636 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2637 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2638 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2639 return method->name()->as_utf8();
2640 JVM_END
2641
2642
2643 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3442 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3443 void* find_result = os::dll_lookup(handle, name);
3444 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3445 find_result != nullptr ? "Found" : "Failed to find",
3446 name, p2i(handle));
3447 return find_result;
3448 JVM_END
3449
3450
3451 // JNI version ///////////////////////////////////////////////////////////////////////////////
3452
3453 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3454 return Threads::is_supported_jni_version_including_1_1(version);
3455 JVM_END
3456
3457
3458 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3459 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3460 JVM_END
3461
3462 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3463 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3464 JVM_END
3465
3466 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3467 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3468 JVM_END
3469
3470 // String support ///////////////////////////////////////////////////////////////////////////
3471
3472 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3473 JvmtiVMObjectAllocEventCollector oam;
3474 if (str == nullptr) return nullptr;
3475 oop string = JNIHandles::resolve_non_null(str);
3476 oop result = StringTable::intern(string, CHECK_NULL);
3477 return (jstring) JNIHandles::make_local(THREAD, result);
3478 JVM_END
3479
3480
3481 // VM Raw monitor support //////////////////////////////////////////////////////////////////////
3523 // the checkPackageAccess relative to the initiating class loader via the
3524 // protection_domain. The protection_domain is passed as null by the java code
3525 // if there is no security manager in 3-arg Class.forName().
3526 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3527
3528 // Check if we should initialize the class
3529 if (init && klass->is_instance_klass()) {
3530 klass->initialize(CHECK_NULL);
3531 }
3532 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3533 }
3534
3535
3536 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3537
3538 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3539 Handle method_handle;
3540 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3541 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3542 Handle receiver(THREAD, JNIHandles::resolve(obj));
3543 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3544 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3545 jobject res = JNIHandles::make_local(THREAD, result);
3546 if (JvmtiExport::should_post_vm_object_alloc()) {
3547 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3548 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3549 if (java_lang_Class::is_primitive(ret_type)) {
3550 // Only for primitive type vm allocates memory for java object.
3551 // See box() method.
3552 JvmtiExport::post_vm_object_alloc(thread, result);
3553 }
3554 }
3555 return res;
3556 } else {
3557 THROW_0(vmSymbols::java_lang_StackOverflowError());
3558 }
3559 JVM_END
3560
3561
3562 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3563 oop constructor_mirror = JNIHandles::resolve(c);
3564 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3565 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3566 jobject res = JNIHandles::make_local(THREAD, result);
3567 if (JvmtiExport::should_post_vm_object_alloc()) {
3568 JvmtiExport::post_vm_object_alloc(thread, result);
3569 }
3570 return res;
3571 JVM_END
3572
3573 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3574
3575 JVM_LEAF(jboolean, JVM_SupportsCX8())
3576 return VM_Version::supports_cx8();
3577 JVM_END
3578
3579 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3580 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3581 assert(k->is_klass(), "just checking");
3582 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3583 JVM_END
3584
|
39 #include "classfile/modules.hpp"
40 #include "classfile/packageEntry.hpp"
41 #include "classfile/stringTable.hpp"
42 #include "classfile/symbolTable.hpp"
43 #include "classfile/systemDictionary.hpp"
44 #include "classfile/vmClasses.hpp"
45 #include "classfile/vmSymbols.hpp"
46 #include "gc/shared/collectedHeap.inline.hpp"
47 #include "interpreter/bytecode.hpp"
48 #include "interpreter/bytecodeUtils.hpp"
49 #include "jfr/jfrEvents.hpp"
50 #include "jvm.h"
51 #include "logging/log.hpp"
52 #include "memory/oopFactory.hpp"
53 #include "memory/referenceType.hpp"
54 #include "memory/resourceArea.hpp"
55 #include "memory/universe.hpp"
56 #include "oops/access.inline.hpp"
57 #include "oops/constantPool.hpp"
58 #include "oops/fieldStreams.inline.hpp"
59 #include "oops/flatArrayKlass.hpp"
60 #include "oops/instanceKlass.hpp"
61 #include "oops/klass.inline.hpp"
62 #include "oops/method.hpp"
63 #include "oops/recordComponent.hpp"
64 #include "oops/objArrayKlass.hpp"
65 #include "oops/objArrayOop.inline.hpp"
66 #include "oops/oop.inline.hpp"
67 #include "prims/foreignGlobals.hpp"
68 #include "prims/jvm_misc.hpp"
69 #include "prims/jvmtiExport.hpp"
70 #include "prims/jvmtiThreadState.inline.hpp"
71 #include "prims/stackwalk.hpp"
72 #include "runtime/arguments.hpp"
73 #include "runtime/atomic.hpp"
74 #include "runtime/continuation.hpp"
75 #include "runtime/globals_extension.hpp"
76 #include "runtime/handles.inline.hpp"
77 #include "runtime/init.hpp"
78 #include "runtime/interfaceSupport.inline.hpp"
79 #include "runtime/deoptimization.hpp"
591 }
592
593 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
594 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
595 start_index, frames_array_h, THREAD);
596 JVM_END
597
598 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
599 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
600 objArrayHandle frames_array_h(THREAD, fa);
601 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
602 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
603
604 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
605 JVM_END
606
607 // java.lang.Object ///////////////////////////////////////////////
608
609
610 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
611 // as implemented in the classic virtual machine; return 0 if object is nullptr
612 if (handle == nullptr) {
613 return 0;
614 }
615 oop obj = JNIHandles::resolve_non_null(handle);
616 if (EnableValhalla && obj->klass()->is_inline_klass()) {
617 JavaValue result(T_INT);
618 JavaCallArguments args;
619 Handle ho(THREAD, obj);
620 args.push_oop(ho);
621 methodHandle method(THREAD, Universe::value_object_hash_code_method());
622 JavaCalls::call(&result, method, &args, THREAD);
623 if (HAS_PENDING_EXCEPTION) {
624 if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
625 Handle e(THREAD, PENDING_EXCEPTION);
626 CLEAR_PENDING_EXCEPTION;
627 THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
628 }
629 }
630 return result.get_jint();
631 } else {
632 return ObjectSynchronizer::FastHashCode(THREAD, obj);
633 }
634 JVM_END
635
636
637 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
638 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
639 JavaThreadInObjectWaitState jtiows(thread, ms != 0);
640 if (JvmtiExport::should_post_monitor_wait()) {
641 JvmtiExport::post_monitor_wait(thread, obj(), ms);
642
643 // The current thread already owns the monitor and it has not yet
644 // been added to the wait queue so the current thread cannot be
645 // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
646 // event handler cannot accidentally consume an unpark() meant for
647 // the ParkEvent associated with this ObjectMonitor.
648 }
649 ObjectSynchronizer::wait(obj, ms, CHECK);
650 JVM_END
651
652
653 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
665 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
666 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
667 Klass* klass = obj->klass();
668 JvmtiVMObjectAllocEventCollector oam;
669
670 #ifdef ASSERT
671 // Just checking that the cloneable flag is set correct
672 if (obj->is_array()) {
673 guarantee(klass->is_cloneable(), "all arrays are cloneable");
674 } else {
675 guarantee(obj->is_instance(), "should be instanceOop");
676 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
677 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
678 }
679 #endif
680
681 // Check if class of obj supports the Cloneable interface.
682 // All arrays are considered to be cloneable (See JLS 20.1.5).
683 // All j.l.r.Reference classes are considered non-cloneable.
684 if (!klass->is_cloneable() ||
685 klass->is_inline_klass() ||
686 (klass->is_instance_klass() &&
687 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
688 ResourceMark rm(THREAD);
689 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
690 }
691
692 // Make shallow object copy
693 const size_t size = obj->size();
694 oop new_obj_oop = nullptr;
695 if (obj->is_array()) {
696 const int length = ((arrayOop)obj())->length();
697 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
698 /* do_zero */ true, CHECK_NULL);
699 } else {
700 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
701 }
702
703 HeapAccess<>::clone(obj(), new_obj_oop, size);
704
705 Handle new_obj(THREAD, new_obj_oop);
1179 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1180 return (jstring) JNIHandles::make_local(THREAD, result);
1181 JVM_END
1182
1183
1184 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1185 JvmtiVMObjectAllocEventCollector oam;
1186 oop mirror = JNIHandles::resolve_non_null(cls);
1187
1188 // Special handling for primitive objects
1189 if (java_lang_Class::is_primitive(mirror)) {
1190 // Primitive objects does not have any interfaces
1191 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1192 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1193 }
1194
1195 Klass* klass = java_lang_Class::as_Klass(mirror);
1196 // Figure size of result array
1197 int size;
1198 if (klass->is_instance_klass()) {
1199 InstanceKlass* ik = InstanceKlass::cast(klass);
1200 size = ik->local_interfaces()->length();
1201 } else {
1202 assert(klass->is_objArray_klass() || klass->is_typeArray_klass() || klass->is_flatArray_klass(), "Illegal mirror klass");
1203 size = 2;
1204 }
1205
1206 // Allocate result array
1207 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1208 objArrayHandle result (THREAD, r);
1209 // Fill in result
1210 if (klass->is_instance_klass()) {
1211 // Regular instance klass, fill in all local interfaces
1212 for (int index = 0; index < size; index++) {
1213 InstanceKlass* ik = InstanceKlass::cast(klass);
1214 Klass* k = ik->local_interfaces()->at(index);
1215 result->obj_at_put(index, k->java_mirror());
1216 }
1217 } else {
1218 // All arrays implement java.lang.Cloneable and java.io.Serializable
1219 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1220 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1221 }
1222 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1223 JVM_END
1224
1225
1226 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1227 oop mirror = JNIHandles::resolve_non_null(cls);
1228 if (java_lang_Class::is_primitive(mirror)) {
1229 return JNI_FALSE;
1230 }
1231 Klass* k = java_lang_Class::as_Klass(mirror);
1232 jboolean result = k->is_interface();
1233 assert(!result || k->is_instance_klass(),
1234 "all interfaces are instance types");
1235 // The compiler intrinsic for isInterface tests the
1236 // Klass::_access_flags bits in the same way.
1237 return result;
1238 JVM_END
1239
1240 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1241 oop mirror = JNIHandles::resolve_non_null(cls);
1242 if (java_lang_Class::is_primitive(mirror)) {
1243 return JNI_FALSE;
1244 }
1245 Klass* k = java_lang_Class::as_Klass(mirror);
1246 return k->is_hidden();
1247 JVM_END
1248
1249 JVM_ENTRY(jboolean, JVM_IsIdentityClass(JNIEnv *env, jclass cls))
1250 oop mirror = JNIHandles::resolve_non_null(cls);
1251 if (java_lang_Class::is_primitive(mirror)) {
1252 return JNI_FALSE;
1253 }
1254 Klass* k = java_lang_Class::as_Klass(mirror);
1255 if (EnableValhalla) {
1256 return k->is_array_klass() || k->is_identity_class();
1257 } else {
1258 return k->is_interface() ? JNI_FALSE : JNI_TRUE;
1259 }
1260 JVM_END
1261
1262 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1263 JvmtiVMObjectAllocEventCollector oam;
1264 oop mirror = JNIHandles::resolve_non_null(cls);
1265 if (java_lang_Class::is_primitive(mirror)) {
1266 // There are no signers for primitive types
1267 return nullptr;
1268 }
1269
1270 objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1271
1272 // If there are no signers set in the class, or if the class
1273 // is an array, return null.
1274 if (signers == nullptr) return nullptr;
1275
1276 // copy of the signers array
1277 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1278 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1279 for (int index = 0; index < signers->length(); index++) {
1280 signers_copy->obj_at_put(index, signers->obj_at(index));
1281 }
1857 int length = components->length();
1858 assert(length >= 0, "unexpected record_components length");
1859 objArrayOop record_components =
1860 oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1861 objArrayHandle components_h (THREAD, record_components);
1862
1863 for (int x = 0; x < length; x++) {
1864 RecordComponent* component = components->at(x);
1865 assert(component != nullptr, "unexpected null record component");
1866 oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1867 components_h->obj_at_put(x, component_oop);
1868 }
1869 return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1870 }
1871
1872 return nullptr;
1873 }
1874 JVM_END
1875
1876 static bool select_method(const methodHandle& method, bool want_constructor) {
1877 bool is_ctor = (method->is_object_constructor() ||
1878 method->is_static_vnew_factory());
1879 if (want_constructor) {
1880 return is_ctor;
1881 } else {
1882 return (!is_ctor &&
1883 !method->is_class_initializer() &&
1884 !method->is_overpass());
1885 }
1886 }
1887
1888 static jobjectArray get_class_declared_methods_helper(
1889 JNIEnv *env,
1890 jclass ofClass, jboolean publicOnly,
1891 bool want_constructor,
1892 Klass* klass, TRAPS) {
1893
1894 JvmtiVMObjectAllocEventCollector oam;
1895
1896 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1897 // Exclude primitive types and array types
1898 if (java_lang_Class::is_primitive(ofMirror)
1899 || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1900 // Return empty array
1901 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1902 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1903 }
1904
1927 }
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() ||
1948 method->is_static_vnew_factory(), "must be");
1949 m = Reflection::new_constructor(method, CHECK_NULL);
1950 } else {
1951 m = Reflection::new_method(method, false, CHECK_NULL);
1952 }
1953 result->obj_at_put(i, m);
1954 }
1955 }
1956
1957 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1958 }
1959
1960 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1961 {
1962 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1963 /*want_constructor*/ false,
1964 vmClasses::reflect_Method_klass(), THREAD);
1965 }
1966 JVM_END
1967
1968 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
2211 constantTag tag = cp->tag_at(index);
2212 if (!tag.is_method() && !tag.is_interface_method()) {
2213 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2214 }
2215 int klass_ref = cp->uncached_klass_ref_index_at(index);
2216 Klass* k_o;
2217 if (force_resolution) {
2218 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2219 } else {
2220 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2221 if (k_o == nullptr) return nullptr;
2222 }
2223 InstanceKlass* k = InstanceKlass::cast(k_o);
2224 Symbol* name = cp->uncached_name_ref_at(index);
2225 Symbol* sig = cp->uncached_signature_ref_at(index);
2226 methodHandle m (THREAD, k->find_method(name, sig));
2227 if (m.is_null()) {
2228 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2229 }
2230 oop method;
2231 if (m->is_object_constructor() || m->is_static_vnew_factory()) {
2232 method = Reflection::new_constructor(m, CHECK_NULL);
2233 } else {
2234 method = Reflection::new_method(m, true, CHECK_NULL);
2235 }
2236 return JNIHandles::make_local(THREAD, method);
2237 }
2238
2239 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2240 {
2241 JvmtiVMObjectAllocEventCollector oam;
2242 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2243 bounds_check(cp, index, CHECK_NULL);
2244 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2245 return res;
2246 }
2247 JVM_END
2248
2249 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2250 {
2251 JvmtiVMObjectAllocEventCollector oam;
2252 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2253 bounds_check(cp, index, CHECK_NULL);
2254 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
2485 Klass* k = java_lang_Class::as_Klass(r);
2486 assert(k->is_instance_klass(), "must be an instance klass");
2487 if (!k->is_instance_klass()) return false;
2488
2489 ResourceMark rm(THREAD);
2490 const char* name = k->name()->as_C_string();
2491 bool system_class = k->class_loader() == nullptr;
2492 return JavaAssertions::enabled(name, system_class);
2493
2494 JVM_END
2495
2496
2497 // Return a new AssertionStatusDirectives object with the fields filled in with
2498 // command-line assertion arguments (i.e., -ea, -da).
2499 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2500 JvmtiVMObjectAllocEventCollector oam;
2501 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2502 return JNIHandles::make_local(THREAD, asd);
2503 JVM_END
2504
2505 // Arrays support /////////////////////////////////////////////////////////////
2506
2507 JVM_ENTRY(jboolean, JVM_ArrayIsAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2508 oop o = JNIHandles::resolve(array);
2509 Klass* k = o->klass();
2510 if ((o == nullptr) || (!k->is_array_klass())) {
2511 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2512 }
2513 return ArrayKlass::cast(k)->element_access_is_atomic();
2514 JVM_END
2515
2516 JVM_ENTRY(jobject, JVM_ArrayEnsureAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2517 oop o = JNIHandles::resolve(array);
2518 Klass* k = o->klass();
2519 if ((o == nullptr) || (!k->is_array_klass())) {
2520 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2521 }
2522 if (k->is_flatArray_klass()) {
2523 FlatArrayKlass* vk = FlatArrayKlass::cast(k);
2524 if (!vk->element_access_is_atomic()) {
2525 /**
2526 * Need to decide how to implement:
2527 *
2528 * 1) Change to objArrayOop layout, therefore oop->klass() differs so
2529 * then "<atomic>[Qfoo;" klass needs to subclass "[Qfoo;" to pass through
2530 * "checkcast" & "instanceof"
2531 *
2532 * 2) Use extra header in the flatArrayOop to flag atomicity required and
2533 * possibly per instance lock structure. Said info, could be placed in
2534 * "trailer" rather than disturb the current arrayOop
2535 */
2536 Unimplemented();
2537 }
2538 }
2539 return array;
2540 JVM_END
2541
2542 // Verification ////////////////////////////////////////////////////////////////////////////////
2543
2544 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2545
2546 // RedefineClasses support: bug 6214132 caused verification to fail.
2547 // All functions from this section should call the jvmtiThreadSate function:
2548 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2549 // The function returns a Klass* of the _scratch_class if the verifier
2550 // was invoked in the middle of the class redefinition.
2551 // Otherwise it returns its argument value which is the _the_class Klass*.
2552 // Please, refer to the description in the jvmtiThreadSate.hpp.
2553
2554 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2555 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2556 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2557 return k->name()->as_utf8();
2558 JVM_END
2559
2560
2561 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
2684 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2685 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2686 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2687 return method->size_of_parameters();
2688 JVM_END
2689
2690
2691 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2692 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2693 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2694 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2695 return method->verifier_max_stack();
2696 JVM_END
2697
2698
2699 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2700 ResourceMark rm(THREAD);
2701 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2702 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2703 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2704 return method->is_object_constructor();
2705 JVM_END
2706
2707
2708 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2709 ResourceMark rm(THREAD);
2710 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2711 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2712 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2713 return method->is_overpass();
2714 JVM_END
2715
2716 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2717 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2718 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2719 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2720 return method->name()->as_utf8();
2721 JVM_END
2722
2723
2724 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3523 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3524 void* find_result = os::dll_lookup(handle, name);
3525 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3526 find_result != nullptr ? "Found" : "Failed to find",
3527 name, p2i(handle));
3528 return find_result;
3529 JVM_END
3530
3531
3532 // JNI version ///////////////////////////////////////////////////////////////////////////////
3533
3534 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3535 return Threads::is_supported_jni_version_including_1_1(version);
3536 JVM_END
3537
3538
3539 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3540 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3541 JVM_END
3542
3543 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3544 return EnableValhalla ? JNI_TRUE : JNI_FALSE;
3545 JVM_END
3546
3547 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3548 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3549 JVM_END
3550
3551 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3552 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3553 JVM_END
3554
3555 // String support ///////////////////////////////////////////////////////////////////////////
3556
3557 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3558 JvmtiVMObjectAllocEventCollector oam;
3559 if (str == nullptr) return nullptr;
3560 oop string = JNIHandles::resolve_non_null(str);
3561 oop result = StringTable::intern(string, CHECK_NULL);
3562 return (jstring) JNIHandles::make_local(THREAD, result);
3563 JVM_END
3564
3565
3566 // VM Raw monitor support //////////////////////////////////////////////////////////////////////
3608 // the checkPackageAccess relative to the initiating class loader via the
3609 // protection_domain. The protection_domain is passed as null by the java code
3610 // if there is no security manager in 3-arg Class.forName().
3611 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3612
3613 // Check if we should initialize the class
3614 if (init && klass->is_instance_klass()) {
3615 klass->initialize(CHECK_NULL);
3616 }
3617 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3618 }
3619
3620
3621 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3622
3623 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3624 Handle method_handle;
3625 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3626 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3627 Handle receiver(THREAD, JNIHandles::resolve(obj));
3628 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3629 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3630 jobject res = JNIHandles::make_local(THREAD, result);
3631 if (JvmtiExport::should_post_vm_object_alloc()) {
3632 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3633 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3634 if (java_lang_Class::is_primitive(ret_type)) {
3635 // Only for primitive type vm allocates memory for java object.
3636 // See box() method.
3637 JvmtiExport::post_vm_object_alloc(thread, result);
3638 }
3639 }
3640 return res;
3641 } else {
3642 THROW_0(vmSymbols::java_lang_StackOverflowError());
3643 }
3644 JVM_END
3645
3646
3647 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3648 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3649 oop constructor_mirror = JNIHandles::resolve(c);
3650 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3651 jobject res = JNIHandles::make_local(THREAD, result);
3652 if (JvmtiExport::should_post_vm_object_alloc()) {
3653 JvmtiExport::post_vm_object_alloc(thread, result);
3654 }
3655 return res;
3656 JVM_END
3657
3658 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3659
3660 JVM_LEAF(jboolean, JVM_SupportsCX8())
3661 return VM_Version::supports_cx8();
3662 JVM_END
3663
3664 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3665 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3666 assert(k->is_klass(), "just checking");
3667 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3668 JVM_END
3669
|