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"
606
607 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
608 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
609 start_index, frames_array_h, THREAD);
610 JVM_END
611
612 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
613 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
614 objArrayHandle frames_array_h(THREAD, fa);
615 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
616 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
617
618 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
619 JVM_END
620
621 // java.lang.Object ///////////////////////////////////////////////
622
623
624 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
625 // as implemented in the classic virtual machine; return 0 if object is null
626 return handle == nullptr ? 0 :
627 checked_cast<jint>(ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)));
628 JVM_END
629
630
631 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
632 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
633 JavaThreadInObjectWaitState jtiows(thread, ms != 0);
634 if (JvmtiExport::should_post_monitor_wait()) {
635 JvmtiExport::post_monitor_wait(thread, obj(), ms);
636
637 // The current thread already owns the monitor and it has not yet
638 // been added to the wait queue so the current thread cannot be
639 // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
640 // event handler cannot accidentally consume an unpark() meant for
641 // the ParkEvent associated with this ObjectMonitor.
642 }
643 ObjectSynchronizer::wait(obj, ms, CHECK);
644 JVM_END
645
646
647 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
659 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
660 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
661 Klass* klass = obj->klass();
662 JvmtiVMObjectAllocEventCollector oam;
663
664 #ifdef ASSERT
665 // Just checking that the cloneable flag is set correct
666 if (obj->is_array()) {
667 guarantee(klass->is_cloneable(), "all arrays are cloneable");
668 } else {
669 guarantee(obj->is_instance(), "should be instanceOop");
670 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
671 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
672 }
673 #endif
674
675 // Check if class of obj supports the Cloneable interface.
676 // All arrays are considered to be cloneable (See JLS 20.1.5).
677 // All j.l.r.Reference classes are considered non-cloneable.
678 if (!klass->is_cloneable() ||
679 (klass->is_instance_klass() &&
680 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
681 ResourceMark rm(THREAD);
682 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
683 }
684
685 // Make shallow object copy
686 const size_t size = obj->size();
687 oop new_obj_oop = nullptr;
688 if (obj->is_array()) {
689 const int length = ((arrayOop)obj())->length();
690 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
691 /* do_zero */ true, CHECK_NULL);
692 } else {
693 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
694 }
695
696 HeapAccess<>::clone(obj(), new_obj_oop, size);
697
698 Handle new_obj(THREAD, new_obj_oop);
1175 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1176 return (jstring) JNIHandles::make_local(THREAD, result);
1177 JVM_END
1178
1179
1180 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1181 JvmtiVMObjectAllocEventCollector oam;
1182 oop mirror = JNIHandles::resolve_non_null(cls);
1183
1184 // Special handling for primitive objects
1185 if (java_lang_Class::is_primitive(mirror)) {
1186 // Primitive objects does not have any interfaces
1187 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1188 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1189 }
1190
1191 Klass* klass = java_lang_Class::as_Klass(mirror);
1192 // Figure size of result array
1193 int size;
1194 if (klass->is_instance_klass()) {
1195 size = InstanceKlass::cast(klass)->local_interfaces()->length();
1196 } else {
1197 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1198 size = 2;
1199 }
1200
1201 // Allocate result array
1202 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1203 objArrayHandle result (THREAD, r);
1204 // Fill in result
1205 if (klass->is_instance_klass()) {
1206 // Regular instance klass, fill in all local interfaces
1207 for (int index = 0; index < size; index++) {
1208 Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1209 result->obj_at_put(index, k->java_mirror());
1210 }
1211 } else {
1212 // All arrays implement java.lang.Cloneable and java.io.Serializable
1213 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1214 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1215 }
1216 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1217 JVM_END
1218
1219
1220 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1221 oop mirror = JNIHandles::resolve_non_null(cls);
1222 if (java_lang_Class::is_primitive(mirror)) {
1223 return JNI_FALSE;
1224 }
1225 Klass* k = java_lang_Class::as_Klass(mirror);
1226 jboolean result = k->is_interface();
1227 assert(!result || k->is_instance_klass(),
1228 "all interfaces are instance types");
1229 // The compiler intrinsic for isInterface tests the
1230 // Klass::_access_flags bits in the same way.
1231 return result;
1232 JVM_END
1233
1234 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1235 oop mirror = JNIHandles::resolve_non_null(cls);
1236 if (java_lang_Class::is_primitive(mirror)) {
1237 return JNI_FALSE;
1238 }
1239 Klass* k = java_lang_Class::as_Klass(mirror);
1240 return k->is_hidden();
1241 JVM_END
1242
1243 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1244 JvmtiVMObjectAllocEventCollector oam;
1245 oop mirror = JNIHandles::resolve_non_null(cls);
1246 if (java_lang_Class::is_primitive(mirror)) {
1247 // There are no signers for primitive types
1248 return nullptr;
1249 }
1250
1251 objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1252
1253 // If there are no signers set in the class, or if the class
1254 // is an array, return null.
1255 if (signers == nullptr) return nullptr;
1256
1257 // copy of the signers array
1258 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1259 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1260 for (int index = 0; index < signers->length(); index++) {
1261 signers_copy->obj_at_put(index, signers->obj_at(index));
1262 }
1837 int length = components->length();
1838 assert(length >= 0, "unexpected record_components length");
1839 objArrayOop record_components =
1840 oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1841 objArrayHandle components_h (THREAD, record_components);
1842
1843 for (int x = 0; x < length; x++) {
1844 RecordComponent* component = components->at(x);
1845 assert(component != nullptr, "unexpected null record component");
1846 oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1847 components_h->obj_at_put(x, component_oop);
1848 }
1849 return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1850 }
1851
1852 return nullptr;
1853 }
1854 JVM_END
1855
1856 static bool select_method(const methodHandle& method, bool want_constructor) {
1857 if (want_constructor) {
1858 return (method->is_initializer() && !method->is_static());
1859 } else {
1860 return (!method->is_initializer() && !method->is_overpass());
1861 }
1862 }
1863
1864 static jobjectArray get_class_declared_methods_helper(
1865 JNIEnv *env,
1866 jclass ofClass, jboolean publicOnly,
1867 bool want_constructor,
1868 Klass* klass, TRAPS) {
1869
1870 JvmtiVMObjectAllocEventCollector oam;
1871
1872 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1873 // Exclude primitive types and array types
1874 if (java_lang_Class::is_primitive(ofMirror)
1875 || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1876 // Return empty array
1877 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1878 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1879 }
1880
1903 }
1904 }
1905
1906 // Allocate result
1907 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1908 objArrayHandle result (THREAD, r);
1909
1910 // Now just put the methods that we selected above, but go by their idnum
1911 // in case of redefinition. The methods can be redefined at any safepoint,
1912 // so above when allocating the oop array and below when creating reflect
1913 // objects.
1914 for (int i = 0; i < num_methods; i++) {
1915 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1916 if (method.is_null()) {
1917 // Method may have been deleted and seems this API can handle null
1918 // Otherwise should probably put a method that throws NSME
1919 result->obj_at_put(i, nullptr);
1920 } else {
1921 oop m;
1922 if (want_constructor) {
1923 m = Reflection::new_constructor(method, CHECK_NULL);
1924 } else {
1925 m = Reflection::new_method(method, false, CHECK_NULL);
1926 }
1927 result->obj_at_put(i, m);
1928 }
1929 }
1930
1931 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1932 }
1933
1934 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1935 {
1936 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1937 /*want_constructor*/ false,
1938 vmClasses::reflect_Method_klass(), THREAD);
1939 }
1940 JVM_END
1941
1942 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
2185 constantTag tag = cp->tag_at(index);
2186 if (!tag.is_method() && !tag.is_interface_method()) {
2187 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2188 }
2189 int klass_ref = cp->uncached_klass_ref_index_at(index);
2190 Klass* k_o;
2191 if (force_resolution) {
2192 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2193 } else {
2194 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2195 if (k_o == nullptr) return nullptr;
2196 }
2197 InstanceKlass* k = InstanceKlass::cast(k_o);
2198 Symbol* name = cp->uncached_name_ref_at(index);
2199 Symbol* sig = cp->uncached_signature_ref_at(index);
2200 methodHandle m (THREAD, k->find_method(name, sig));
2201 if (m.is_null()) {
2202 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2203 }
2204 oop method;
2205 if (!m->is_initializer() || m->is_static()) {
2206 method = Reflection::new_method(m, true, CHECK_NULL);
2207 } else {
2208 method = Reflection::new_constructor(m, CHECK_NULL);
2209 }
2210 return JNIHandles::make_local(THREAD, method);
2211 }
2212
2213 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2214 {
2215 JvmtiVMObjectAllocEventCollector oam;
2216 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2217 bounds_check(cp, index, CHECK_NULL);
2218 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2219 return res;
2220 }
2221 JVM_END
2222
2223 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2224 {
2225 JvmtiVMObjectAllocEventCollector oam;
2226 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2227 bounds_check(cp, index, CHECK_NULL);
2228 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
2459 Klass* k = java_lang_Class::as_Klass(r);
2460 assert(k->is_instance_klass(), "must be an instance klass");
2461 if (!k->is_instance_klass()) return false;
2462
2463 ResourceMark rm(THREAD);
2464 const char* name = k->name()->as_C_string();
2465 bool system_class = k->class_loader() == nullptr;
2466 return JavaAssertions::enabled(name, system_class);
2467
2468 JVM_END
2469
2470
2471 // Return a new AssertionStatusDirectives object with the fields filled in with
2472 // command-line assertion arguments (i.e., -ea, -da).
2473 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2474 JvmtiVMObjectAllocEventCollector oam;
2475 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2476 return JNIHandles::make_local(THREAD, asd);
2477 JVM_END
2478
2479 // Verification ////////////////////////////////////////////////////////////////////////////////
2480
2481 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2482
2483 // RedefineClasses support: bug 6214132 caused verification to fail.
2484 // All functions from this section should call the jvmtiThreadSate function:
2485 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2486 // The function returns a Klass* of the _scratch_class if the verifier
2487 // was invoked in the middle of the class redefinition.
2488 // Otherwise it returns its argument value which is the _the_class Klass*.
2489 // Please, refer to the description in the jvmtiThreadSate.hpp.
2490
2491 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2492 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2493 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2494 return k->name()->as_utf8();
2495 JVM_END
2496
2497
2498 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
2621 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2622 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2623 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2624 return method->size_of_parameters();
2625 JVM_END
2626
2627
2628 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
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->verifier_max_stack();
2633 JVM_END
2634
2635
2636 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2637 ResourceMark rm(THREAD);
2638 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2639 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2640 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2641 return method->name() == vmSymbols::object_initializer_name();
2642 JVM_END
2643
2644
2645 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2646 ResourceMark rm(THREAD);
2647 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2648 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2649 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2650 return method->is_overpass();
2651 JVM_END
2652
2653 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2654 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2655 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2656 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2657 return method->name()->as_utf8();
2658 JVM_END
2659
2660
2661 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3459 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3460 void* find_result = os::dll_lookup(handle, name);
3461 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3462 find_result != nullptr ? "Found" : "Failed to find",
3463 name, p2i(handle));
3464 return find_result;
3465 JVM_END
3466
3467
3468 // JNI version ///////////////////////////////////////////////////////////////////////////////
3469
3470 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3471 return Threads::is_supported_jni_version_including_1_1(version);
3472 JVM_END
3473
3474
3475 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3476 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3477 JVM_END
3478
3479 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3480 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3481 JVM_END
3482
3483 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3484 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3485 JVM_END
3486
3487 // String support ///////////////////////////////////////////////////////////////////////////
3488
3489 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3490 JvmtiVMObjectAllocEventCollector oam;
3491 if (str == nullptr) return nullptr;
3492 oop string = JNIHandles::resolve_non_null(str);
3493 oop result = StringTable::intern(string, CHECK_NULL);
3494 return (jstring) JNIHandles::make_local(THREAD, result);
3495 JVM_END
3496
3497
3498 // VM Raw monitor support //////////////////////////////////////////////////////////////////////
3540 // the checkPackageAccess relative to the initiating class loader via the
3541 // protection_domain. The protection_domain is passed as null by the java code
3542 // if there is no security manager in 3-arg Class.forName().
3543 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3544
3545 // Check if we should initialize the class
3546 if (init && klass->is_instance_klass()) {
3547 klass->initialize(CHECK_NULL);
3548 }
3549 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3550 }
3551
3552
3553 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3554
3555 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3556 Handle method_handle;
3557 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3558 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3559 Handle receiver(THREAD, JNIHandles::resolve(obj));
3560 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3561 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3562 jobject res = JNIHandles::make_local(THREAD, result);
3563 if (JvmtiExport::should_post_vm_object_alloc()) {
3564 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3565 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3566 if (java_lang_Class::is_primitive(ret_type)) {
3567 // Only for primitive type vm allocates memory for java object.
3568 // See box() method.
3569 JvmtiExport::post_vm_object_alloc(thread, result);
3570 }
3571 }
3572 return res;
3573 } else {
3574 THROW_0(vmSymbols::java_lang_StackOverflowError());
3575 }
3576 JVM_END
3577
3578
3579 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3580 oop constructor_mirror = JNIHandles::resolve(c);
3581 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3582 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3583 jobject res = JNIHandles::make_local(THREAD, result);
3584 if (JvmtiExport::should_post_vm_object_alloc()) {
3585 JvmtiExport::post_vm_object_alloc(thread, result);
3586 }
3587 return res;
3588 JVM_END
3589
3590 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3591
3592 JVM_LEAF(jboolean, JVM_SupportsCX8())
3593 return VM_Version::supports_cx8();
3594 JVM_END
3595
3596 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3597 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3598 assert(k->is_klass(), "just checking");
3599 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3600 JVM_END
3601
|
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"
607
608 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
609 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
610 start_index, frames_array_h, THREAD);
611 JVM_END
612
613 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
614 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
615 objArrayHandle frames_array_h(THREAD, fa);
616 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
617 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
618
619 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
620 JVM_END
621
622 // java.lang.Object ///////////////////////////////////////////////
623
624
625 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
626 // as implemented in the classic virtual machine; return 0 if object is null
627 if (handle == nullptr) {
628 return 0;
629 }
630 oop obj = JNIHandles::resolve_non_null(handle);
631 if (EnableValhalla && obj->klass()->is_inline_klass()) {
632 JavaValue result(T_INT);
633 JavaCallArguments args;
634 Handle ho(THREAD, obj);
635 args.push_oop(ho);
636 methodHandle method(THREAD, Universe::value_object_hash_code_method());
637 JavaCalls::call(&result, method, &args, THREAD);
638 if (HAS_PENDING_EXCEPTION) {
639 if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
640 Handle e(THREAD, PENDING_EXCEPTION);
641 CLEAR_PENDING_EXCEPTION;
642 THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
643 }
644 }
645 return result.get_jint();
646 } else {
647 return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj));
648 }
649 JVM_END
650
651
652 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
653 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
654 JavaThreadInObjectWaitState jtiows(thread, ms != 0);
655 if (JvmtiExport::should_post_monitor_wait()) {
656 JvmtiExport::post_monitor_wait(thread, obj(), ms);
657
658 // The current thread already owns the monitor and it has not yet
659 // been added to the wait queue so the current thread cannot be
660 // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
661 // event handler cannot accidentally consume an unpark() meant for
662 // the ParkEvent associated with this ObjectMonitor.
663 }
664 ObjectSynchronizer::wait(obj, ms, CHECK);
665 JVM_END
666
667
668 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
680 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
681 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
682 Klass* klass = obj->klass();
683 JvmtiVMObjectAllocEventCollector oam;
684
685 #ifdef ASSERT
686 // Just checking that the cloneable flag is set correct
687 if (obj->is_array()) {
688 guarantee(klass->is_cloneable(), "all arrays are cloneable");
689 } else {
690 guarantee(obj->is_instance(), "should be instanceOop");
691 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
692 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
693 }
694 #endif
695
696 // Check if class of obj supports the Cloneable interface.
697 // All arrays are considered to be cloneable (See JLS 20.1.5).
698 // All j.l.r.Reference classes are considered non-cloneable.
699 if (!klass->is_cloneable() ||
700 klass->is_inline_klass() ||
701 (klass->is_instance_klass() &&
702 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
703 ResourceMark rm(THREAD);
704 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
705 }
706
707 // Make shallow object copy
708 const size_t size = obj->size();
709 oop new_obj_oop = nullptr;
710 if (obj->is_array()) {
711 const int length = ((arrayOop)obj())->length();
712 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
713 /* do_zero */ true, CHECK_NULL);
714 } else {
715 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
716 }
717
718 HeapAccess<>::clone(obj(), new_obj_oop, size);
719
720 Handle new_obj(THREAD, new_obj_oop);
1197 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1198 return (jstring) JNIHandles::make_local(THREAD, result);
1199 JVM_END
1200
1201
1202 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1203 JvmtiVMObjectAllocEventCollector oam;
1204 oop mirror = JNIHandles::resolve_non_null(cls);
1205
1206 // Special handling for primitive objects
1207 if (java_lang_Class::is_primitive(mirror)) {
1208 // Primitive objects does not have any interfaces
1209 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1210 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1211 }
1212
1213 Klass* klass = java_lang_Class::as_Klass(mirror);
1214 // Figure size of result array
1215 int size;
1216 if (klass->is_instance_klass()) {
1217 InstanceKlass* ik = InstanceKlass::cast(klass);
1218 size = ik->local_interfaces()->length();
1219 } else {
1220 assert(klass->is_objArray_klass() || klass->is_typeArray_klass() || klass->is_flatArray_klass(), "Illegal mirror klass");
1221 size = 2;
1222 }
1223
1224 // Allocate result array
1225 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1226 objArrayHandle result (THREAD, r);
1227 // Fill in result
1228 if (klass->is_instance_klass()) {
1229 // Regular instance klass, fill in all local interfaces
1230 for (int index = 0; index < size; index++) {
1231 InstanceKlass* ik = InstanceKlass::cast(klass);
1232 Klass* k = ik->local_interfaces()->at(index);
1233 result->obj_at_put(index, k->java_mirror());
1234 }
1235 } else {
1236 // All arrays implement java.lang.Cloneable and java.io.Serializable
1237 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1238 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1239 }
1240 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1241 JVM_END
1242
1243
1244 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1245 oop mirror = JNIHandles::resolve_non_null(cls);
1246 if (java_lang_Class::is_primitive(mirror)) {
1247 return JNI_FALSE;
1248 }
1249 Klass* k = java_lang_Class::as_Klass(mirror);
1250 jboolean result = k->is_interface();
1251 assert(!result || k->is_instance_klass(),
1252 "all interfaces are instance types");
1253 // The compiler intrinsic for isInterface tests the
1254 // Klass::_access_flags bits in the same way.
1255 return result;
1256 JVM_END
1257
1258 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1259 oop mirror = JNIHandles::resolve_non_null(cls);
1260 if (java_lang_Class::is_primitive(mirror)) {
1261 return JNI_FALSE;
1262 }
1263 Klass* k = java_lang_Class::as_Klass(mirror);
1264 return k->is_hidden();
1265 JVM_END
1266
1267 JVM_ENTRY(jboolean, JVM_IsIdentityClass(JNIEnv *env, jclass cls))
1268 oop mirror = JNIHandles::resolve_non_null(cls);
1269 if (java_lang_Class::is_primitive(mirror)) {
1270 return JNI_FALSE;
1271 }
1272 Klass* k = java_lang_Class::as_Klass(mirror);
1273 if (EnableValhalla) {
1274 return k->is_array_klass() || k->is_identity_class();
1275 } else {
1276 return k->is_interface() ? JNI_FALSE : JNI_TRUE;
1277 }
1278 JVM_END
1279
1280 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1281 JvmtiVMObjectAllocEventCollector oam;
1282 oop mirror = JNIHandles::resolve_non_null(cls);
1283 if (java_lang_Class::is_primitive(mirror)) {
1284 // There are no signers for primitive types
1285 return nullptr;
1286 }
1287
1288 objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1289
1290 // If there are no signers set in the class, or if the class
1291 // is an array, return null.
1292 if (signers == nullptr) return nullptr;
1293
1294 // copy of the signers array
1295 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1296 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1297 for (int index = 0; index < signers->length(); index++) {
1298 signers_copy->obj_at_put(index, signers->obj_at(index));
1299 }
1874 int length = components->length();
1875 assert(length >= 0, "unexpected record_components length");
1876 objArrayOop record_components =
1877 oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1878 objArrayHandle components_h (THREAD, record_components);
1879
1880 for (int x = 0; x < length; x++) {
1881 RecordComponent* component = components->at(x);
1882 assert(component != nullptr, "unexpected null record component");
1883 oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1884 components_h->obj_at_put(x, component_oop);
1885 }
1886 return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1887 }
1888
1889 return nullptr;
1890 }
1891 JVM_END
1892
1893 static bool select_method(const methodHandle& method, bool want_constructor) {
1894 bool is_ctor = (method->is_object_constructor() ||
1895 method->is_static_vnew_factory());
1896 if (want_constructor) {
1897 return is_ctor;
1898 } else {
1899 return (!is_ctor &&
1900 !method->is_class_initializer() &&
1901 !method->is_overpass());
1902 }
1903 }
1904
1905 static jobjectArray get_class_declared_methods_helper(
1906 JNIEnv *env,
1907 jclass ofClass, jboolean publicOnly,
1908 bool want_constructor,
1909 Klass* klass, TRAPS) {
1910
1911 JvmtiVMObjectAllocEventCollector oam;
1912
1913 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1914 // Exclude primitive types and array types
1915 if (java_lang_Class::is_primitive(ofMirror)
1916 || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1917 // Return empty array
1918 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1919 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1920 }
1921
1944 }
1945 }
1946
1947 // Allocate result
1948 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1949 objArrayHandle result (THREAD, r);
1950
1951 // Now just put the methods that we selected above, but go by their idnum
1952 // in case of redefinition. The methods can be redefined at any safepoint,
1953 // so above when allocating the oop array and below when creating reflect
1954 // objects.
1955 for (int i = 0; i < num_methods; i++) {
1956 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1957 if (method.is_null()) {
1958 // Method may have been deleted and seems this API can handle null
1959 // Otherwise should probably put a method that throws NSME
1960 result->obj_at_put(i, nullptr);
1961 } else {
1962 oop m;
1963 if (want_constructor) {
1964 assert(method->is_object_constructor() ||
1965 method->is_static_vnew_factory(), "must be");
1966 m = Reflection::new_constructor(method, CHECK_NULL);
1967 } else {
1968 m = Reflection::new_method(method, false, CHECK_NULL);
1969 }
1970 result->obj_at_put(i, m);
1971 }
1972 }
1973
1974 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1975 }
1976
1977 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1978 {
1979 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1980 /*want_constructor*/ false,
1981 vmClasses::reflect_Method_klass(), THREAD);
1982 }
1983 JVM_END
1984
1985 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
2228 constantTag tag = cp->tag_at(index);
2229 if (!tag.is_method() && !tag.is_interface_method()) {
2230 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2231 }
2232 int klass_ref = cp->uncached_klass_ref_index_at(index);
2233 Klass* k_o;
2234 if (force_resolution) {
2235 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2236 } else {
2237 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2238 if (k_o == nullptr) return nullptr;
2239 }
2240 InstanceKlass* k = InstanceKlass::cast(k_o);
2241 Symbol* name = cp->uncached_name_ref_at(index);
2242 Symbol* sig = cp->uncached_signature_ref_at(index);
2243 methodHandle m (THREAD, k->find_method(name, sig));
2244 if (m.is_null()) {
2245 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2246 }
2247 oop method;
2248 if (m->is_object_constructor() || m->is_static_vnew_factory()) {
2249 method = Reflection::new_constructor(m, CHECK_NULL);
2250 } else {
2251 method = Reflection::new_method(m, true, CHECK_NULL);
2252 }
2253 return JNIHandles::make_local(THREAD, method);
2254 }
2255
2256 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2257 {
2258 JvmtiVMObjectAllocEventCollector oam;
2259 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2260 bounds_check(cp, index, CHECK_NULL);
2261 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2262 return res;
2263 }
2264 JVM_END
2265
2266 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2267 {
2268 JvmtiVMObjectAllocEventCollector oam;
2269 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2270 bounds_check(cp, index, CHECK_NULL);
2271 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
2502 Klass* k = java_lang_Class::as_Klass(r);
2503 assert(k->is_instance_klass(), "must be an instance klass");
2504 if (!k->is_instance_klass()) return false;
2505
2506 ResourceMark rm(THREAD);
2507 const char* name = k->name()->as_C_string();
2508 bool system_class = k->class_loader() == nullptr;
2509 return JavaAssertions::enabled(name, system_class);
2510
2511 JVM_END
2512
2513
2514 // Return a new AssertionStatusDirectives object with the fields filled in with
2515 // command-line assertion arguments (i.e., -ea, -da).
2516 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2517 JvmtiVMObjectAllocEventCollector oam;
2518 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2519 return JNIHandles::make_local(THREAD, asd);
2520 JVM_END
2521
2522 // Arrays support /////////////////////////////////////////////////////////////
2523
2524 JVM_ENTRY(jboolean, JVM_ArrayIsAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2525 oop o = JNIHandles::resolve(array);
2526 Klass* k = o->klass();
2527 if ((o == nullptr) || (!k->is_array_klass())) {
2528 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2529 }
2530 return ArrayKlass::cast(k)->element_access_is_atomic();
2531 JVM_END
2532
2533 JVM_ENTRY(jobject, JVM_ArrayEnsureAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2534 oop o = JNIHandles::resolve(array);
2535 Klass* k = o->klass();
2536 if ((o == nullptr) || (!k->is_array_klass())) {
2537 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2538 }
2539 if (k->is_flatArray_klass()) {
2540 FlatArrayKlass* vk = FlatArrayKlass::cast(k);
2541 if (!vk->element_access_is_atomic()) {
2542 /**
2543 * Need to decide how to implement:
2544 *
2545 * 1) Change to objArrayOop layout, therefore oop->klass() differs so
2546 * then "<atomic>[Qfoo;" klass needs to subclass "[Qfoo;" to pass through
2547 * "checkcast" & "instanceof"
2548 *
2549 * 2) Use extra header in the flatArrayOop to flag atomicity required and
2550 * possibly per instance lock structure. Said info, could be placed in
2551 * "trailer" rather than disturb the current arrayOop
2552 */
2553 Unimplemented();
2554 }
2555 }
2556 return array;
2557 JVM_END
2558
2559 // Verification ////////////////////////////////////////////////////////////////////////////////
2560
2561 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2562
2563 // RedefineClasses support: bug 6214132 caused verification to fail.
2564 // All functions from this section should call the jvmtiThreadSate function:
2565 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2566 // The function returns a Klass* of the _scratch_class if the verifier
2567 // was invoked in the middle of the class redefinition.
2568 // Otherwise it returns its argument value which is the _the_class Klass*.
2569 // Please, refer to the description in the jvmtiThreadSate.hpp.
2570
2571 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2572 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2573 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2574 return k->name()->as_utf8();
2575 JVM_END
2576
2577
2578 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
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->size_of_parameters();
2705 JVM_END
2706
2707
2708 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2709 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2710 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2711 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2712 return method->verifier_max_stack();
2713 JVM_END
2714
2715
2716 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2717 ResourceMark rm(THREAD);
2718 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2719 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2720 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2721 return method->is_object_constructor();
2722 JVM_END
2723
2724
2725 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2726 ResourceMark rm(THREAD);
2727 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2728 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2729 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2730 return method->is_overpass();
2731 JVM_END
2732
2733 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2734 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2735 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2736 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2737 return method->name()->as_utf8();
2738 JVM_END
2739
2740
2741 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3539 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3540 void* find_result = os::dll_lookup(handle, name);
3541 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3542 find_result != nullptr ? "Found" : "Failed to find",
3543 name, p2i(handle));
3544 return find_result;
3545 JVM_END
3546
3547
3548 // JNI version ///////////////////////////////////////////////////////////////////////////////
3549
3550 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3551 return Threads::is_supported_jni_version_including_1_1(version);
3552 JVM_END
3553
3554
3555 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3556 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3557 JVM_END
3558
3559 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3560 return EnableValhalla ? JNI_TRUE : JNI_FALSE;
3561 JVM_END
3562
3563 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3564 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3565 JVM_END
3566
3567 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3568 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3569 JVM_END
3570
3571 // String support ///////////////////////////////////////////////////////////////////////////
3572
3573 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3574 JvmtiVMObjectAllocEventCollector oam;
3575 if (str == nullptr) return nullptr;
3576 oop string = JNIHandles::resolve_non_null(str);
3577 oop result = StringTable::intern(string, CHECK_NULL);
3578 return (jstring) JNIHandles::make_local(THREAD, result);
3579 JVM_END
3580
3581
3582 // VM Raw monitor support //////////////////////////////////////////////////////////////////////
3624 // the checkPackageAccess relative to the initiating class loader via the
3625 // protection_domain. The protection_domain is passed as null by the java code
3626 // if there is no security manager in 3-arg Class.forName().
3627 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3628
3629 // Check if we should initialize the class
3630 if (init && klass->is_instance_klass()) {
3631 klass->initialize(CHECK_NULL);
3632 }
3633 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3634 }
3635
3636
3637 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3638
3639 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3640 Handle method_handle;
3641 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3642 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3643 Handle receiver(THREAD, JNIHandles::resolve(obj));
3644 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3645 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3646 jobject res = JNIHandles::make_local(THREAD, result);
3647 if (JvmtiExport::should_post_vm_object_alloc()) {
3648 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3649 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3650 if (java_lang_Class::is_primitive(ret_type)) {
3651 // Only for primitive type vm allocates memory for java object.
3652 // See box() method.
3653 JvmtiExport::post_vm_object_alloc(thread, result);
3654 }
3655 }
3656 return res;
3657 } else {
3658 THROW_0(vmSymbols::java_lang_StackOverflowError());
3659 }
3660 JVM_END
3661
3662
3663 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3664 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3665 oop constructor_mirror = JNIHandles::resolve(c);
3666 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3667 jobject res = JNIHandles::make_local(THREAD, result);
3668 if (JvmtiExport::should_post_vm_object_alloc()) {
3669 JvmtiExport::post_vm_object_alloc(thread, result);
3670 }
3671 return res;
3672 JVM_END
3673
3674 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3675
3676 JVM_LEAF(jboolean, JVM_SupportsCX8())
3677 return VM_Version::supports_cx8();
3678 JVM_END
3679
3680 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3681 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3682 assert(k->is_klass(), "just checking");
3683 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3684 JVM_END
3685
|