41 #include "classfile/modules.hpp"
42 #include "classfile/packageEntry.hpp"
43 #include "classfile/stringTable.hpp"
44 #include "classfile/symbolTable.hpp"
45 #include "classfile/systemDictionary.hpp"
46 #include "classfile/vmClasses.hpp"
47 #include "classfile/vmSymbols.hpp"
48 #include "gc/shared/collectedHeap.inline.hpp"
49 #include "interpreter/bytecode.hpp"
50 #include "interpreter/bytecodeUtils.hpp"
51 #include "jfr/jfrEvents.hpp"
52 #include "jvm.h"
53 #include "logging/log.hpp"
54 #include "memory/oopFactory.hpp"
55 #include "memory/referenceType.hpp"
56 #include "memory/resourceArea.hpp"
57 #include "memory/universe.hpp"
58 #include "oops/access.inline.hpp"
59 #include "oops/constantPool.hpp"
60 #include "oops/fieldStreams.inline.hpp"
61 #include "oops/instanceKlass.hpp"
62 #include "oops/klass.inline.hpp"
63 #include "oops/method.hpp"
64 #include "oops/recordComponent.hpp"
65 #include "oops/objArrayKlass.hpp"
66 #include "oops/objArrayOop.inline.hpp"
67 #include "oops/oop.inline.hpp"
68 #include "prims/foreignGlobals.hpp"
69 #include "prims/jvm_misc.hpp"
70 #include "prims/jvmtiExport.hpp"
71 #include "prims/jvmtiThreadState.inline.hpp"
72 #include "prims/stackwalk.hpp"
73 #include "runtime/arguments.hpp"
74 #include "runtime/atomic.hpp"
75 #include "runtime/continuation.hpp"
76 #include "runtime/globals_extension.hpp"
77 #include "runtime/handles.inline.hpp"
78 #include "runtime/init.hpp"
79 #include "runtime/interfaceSupport.inline.hpp"
80 #include "runtime/deoptimization.hpp"
396
397 return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
398 JVM_END
399
400
401 /*
402 * Return the temporary directory that the VM uses for the attach
403 * and perf data files.
404 *
405 * It is important that this directory is well-known and the
406 * same for all VM instances. It cannot be affected by configuration
407 * variables such as java.io.tmpdir.
408 */
409 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
410 HandleMark hm(THREAD);
411 const char* temp_dir = os::get_temp_directory();
412 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
413 return (jstring) JNIHandles::make_local(THREAD, h());
414 JVM_END
415
416
417 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
418
419 extern volatile jint vm_created;
420
421 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
422 EventShutdown event;
423 if (event.should_commit()) {
424 event.set_reason("Shutdown requested from Java");
425 event.commit();
426 }
427 JVM_END
428
429
430 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
431 before_exit(thread, true);
432 vm_exit(code);
433 JVM_END
434
435
604
605 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
606 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
607 start_index, frames_array_h, THREAD);
608 JVM_END
609
610 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
611 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
612 objArrayHandle frames_array_h(THREAD, fa);
613 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
614 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
615
616 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
617 JVM_END
618
619 // java.lang.Object ///////////////////////////////////////////////
620
621
622 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
623 // as implemented in the classic virtual machine; return 0 if object is null
624 return handle == nullptr ? 0 :
625 checked_cast<jint>(ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)));
626 JVM_END
627
628
629 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
630 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
631 ObjectSynchronizer::wait(obj, ms, CHECK);
632 JVM_END
633
634
635 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
636 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
637 ObjectSynchronizer::notify(obj, CHECK);
638 JVM_END
639
640
641 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
642 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
643 ObjectSynchronizer::notifyall(obj, CHECK);
644 JVM_END
645
653 // Just checking that the cloneable flag is set correct
654 if (obj->is_array()) {
655 guarantee(klass->is_cloneable(), "all arrays are cloneable");
656 } else {
657 guarantee(obj->is_instance(), "should be instanceOop");
658 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
659 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
660 }
661 #endif
662
663 // Check if class of obj supports the Cloneable interface.
664 // All arrays are considered to be cloneable (See JLS 20.1.5).
665 // All j.l.r.Reference classes are considered non-cloneable.
666 if (!klass->is_cloneable() ||
667 (klass->is_instance_klass() &&
668 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
669 ResourceMark rm(THREAD);
670 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
671 }
672
673 // Make shallow object copy
674 const size_t size = obj->size();
675 oop new_obj_oop = nullptr;
676 if (obj->is_array()) {
677 const int length = ((arrayOop)obj())->length();
678 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
679 /* do_zero */ true, CHECK_NULL);
680 } else {
681 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
682 }
683
684 HeapAccess<>::clone(obj(), new_obj_oop, size);
685
686 Handle new_obj(THREAD, new_obj_oop);
687 // Caution: this involves a java upcall, so the clone should be
688 // "gc-robust" by this stage.
689 if (klass->has_finalizer()) {
690 assert(obj->is_instance(), "should be instanceOop");
691 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
692 new_obj = Handle(THREAD, new_obj_oop);
1147 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1148 return (jstring) JNIHandles::make_local(THREAD, result);
1149 JVM_END
1150
1151
1152 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1153 JvmtiVMObjectAllocEventCollector oam;
1154 oop mirror = JNIHandles::resolve_non_null(cls);
1155
1156 // Special handling for primitive objects
1157 if (java_lang_Class::is_primitive(mirror)) {
1158 // Primitive objects does not have any interfaces
1159 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1160 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1161 }
1162
1163 Klass* klass = java_lang_Class::as_Klass(mirror);
1164 // Figure size of result array
1165 int size;
1166 if (klass->is_instance_klass()) {
1167 size = InstanceKlass::cast(klass)->local_interfaces()->length();
1168 } else {
1169 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1170 size = 2;
1171 }
1172
1173 // Allocate result array
1174 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1175 objArrayHandle result (THREAD, r);
1176 // Fill in result
1177 if (klass->is_instance_klass()) {
1178 // Regular instance klass, fill in all local interfaces
1179 for (int index = 0; index < size; index++) {
1180 Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1181 result->obj_at_put(index, k->java_mirror());
1182 }
1183 } else {
1184 // All arrays implement java.lang.Cloneable and java.io.Serializable
1185 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1186 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1187 }
1188 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1189 JVM_END
1190
1191
1192 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1193 oop mirror = JNIHandles::resolve_non_null(cls);
1194 if (java_lang_Class::is_primitive(mirror)) {
1195 return JNI_FALSE;
1196 }
1197 Klass* k = java_lang_Class::as_Klass(mirror);
1198 return k->is_hidden();
1199 JVM_END
1200
1201
1202 class ScopedValueBindingsResolver {
1203 public:
1204 InstanceKlass* Carrier_klass;
1205 ScopedValueBindingsResolver(JavaThread* THREAD) {
1206 Klass *k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ScopedValue_Carrier(), true, THREAD);
1207 Carrier_klass = InstanceKlass::cast(k);
1208 }
1209 };
1210
1211 JVM_ENTRY(jobject, JVM_FindScopedValueBindings(JNIEnv *env, jclass cls))
1212 ResourceMark rm(THREAD);
1213 GrowableArray<Handle>* local_array = new GrowableArray<Handle>(12);
1214 JvmtiVMObjectAllocEventCollector oam;
1215
1216 static ScopedValueBindingsResolver resolver(THREAD);
1217
1218 // Iterate through Java frames
1219 vframeStream vfst(thread);
1220 for(; !vfst.at_end(); vfst.next()) {
1665 }
1666
1667 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1668
1669 // Ensure class is linked
1670 k->link_class(CHECK_NULL);
1671
1672 Array<Method*>* methods = k->methods();
1673 int methods_length = methods->length();
1674
1675 // Save original method_idnum in case of redefinition, which can change
1676 // the idnum of obsolete methods. The new method will have the same idnum
1677 // but if we refresh the methods array, the counts will be wrong.
1678 ResourceMark rm(THREAD);
1679 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1680 int num_methods = 0;
1681
1682 // Select methods matching the criteria.
1683 for (int i = 0; i < methods_length; i++) {
1684 Method* method = methods->at(i);
1685 if (want_constructor && !method->is_object_initializer()) {
1686 continue;
1687 }
1688 if (!want_constructor &&
1689 (method->is_object_initializer() || method->is_static_initializer() ||
1690 method->is_overpass())) {
1691 continue;
1692 }
1693 if (publicOnly && !method->is_public()) {
1694 continue;
1695 }
1696 idnums->push(method->method_idnum());
1697 ++num_methods;
1698 }
1699
1700 // Allocate result
1701 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1702 objArrayHandle result (THREAD, r);
1703
1704 // Now just put the methods that we selected above, but go by their idnum
1705 // in case of redefinition. The methods can be redefined at any safepoint,
1706 // so above when allocating the oop array and below when creating reflect
1707 // objects.
1708 for (int i = 0; i < num_methods; i++) {
1709 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1710 if (method.is_null()) {
1711 // Method may have been deleted and seems this API can handle null
1712 // Otherwise should probably put a method that throws NSME
1713 result->obj_at_put(i, nullptr);
1714 } else {
1715 oop m;
1716 if (want_constructor) {
1717 m = Reflection::new_constructor(method, CHECK_NULL);
1718 } else {
1719 m = Reflection::new_method(method, false, CHECK_NULL);
1720 }
1721 result->obj_at_put(i, m);
1722 }
1723 }
1724
1725 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1726 }
1727
1728 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1729 {
1730 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1731 /*want_constructor*/ false,
1732 vmClasses::reflect_Method_klass(), THREAD);
1733 }
1734 JVM_END
1735
1736 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1979 constantTag tag = cp->tag_at(index);
1980 if (!tag.is_method() && !tag.is_interface_method()) {
1981 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
1982 }
1983 int klass_ref = cp->uncached_klass_ref_index_at(index);
1984 Klass* k_o;
1985 if (force_resolution) {
1986 k_o = cp->klass_at(klass_ref, CHECK_NULL);
1987 } else {
1988 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
1989 if (k_o == nullptr) return nullptr;
1990 }
1991 InstanceKlass* k = InstanceKlass::cast(k_o);
1992 Symbol* name = cp->uncached_name_ref_at(index);
1993 Symbol* sig = cp->uncached_signature_ref_at(index);
1994 methodHandle m (THREAD, k->find_method(name, sig));
1995 if (m.is_null()) {
1996 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
1997 }
1998 oop method;
1999 if (m->is_object_initializer()) {
2000 method = Reflection::new_constructor(m, CHECK_NULL);
2001 } else {
2002 // new_method accepts <clinit> as Method here
2003 method = Reflection::new_method(m, true, CHECK_NULL);
2004 }
2005 return JNIHandles::make_local(THREAD, method);
2006 }
2007
2008 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2009 {
2010 JvmtiVMObjectAllocEventCollector oam;
2011 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2012 bounds_check(cp, index, CHECK_NULL);
2013 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2014 return res;
2015 }
2016 JVM_END
2017
2018 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2019 {
2020 JvmtiVMObjectAllocEventCollector oam;
2021 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2022 bounds_check(cp, index, CHECK_NULL);
2254 Klass* k = java_lang_Class::as_Klass(r);
2255 assert(k->is_instance_klass(), "must be an instance klass");
2256 if (!k->is_instance_klass()) return false;
2257
2258 ResourceMark rm(THREAD);
2259 const char* name = k->name()->as_C_string();
2260 bool system_class = k->class_loader() == nullptr;
2261 return JavaAssertions::enabled(name, system_class);
2262
2263 JVM_END
2264
2265
2266 // Return a new AssertionStatusDirectives object with the fields filled in with
2267 // command-line assertion arguments (i.e., -ea, -da).
2268 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2269 JvmtiVMObjectAllocEventCollector oam;
2270 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2271 return JNIHandles::make_local(THREAD, asd);
2272 JVM_END
2273
2274 // Verification ////////////////////////////////////////////////////////////////////////////////
2275
2276 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2277
2278 // RedefineClasses support: bug 6214132 caused verification to fail.
2279 // All functions from this section should call the jvmtiThreadSate function:
2280 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2281 // The function returns a Klass* of the _scratch_class if the verifier
2282 // was invoked in the middle of the class redefinition.
2283 // Otherwise it returns its argument value which is the _the_class Klass*.
2284 // Please, refer to the description in the jvmtiThreadState.hpp.
2285
2286 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
2287 oop mirror = JNIHandles::resolve_non_null(cls);
2288 if (java_lang_Class::is_primitive(mirror)) {
2289 return JNI_FALSE;
2290 }
2291 Klass* k = java_lang_Class::as_Klass(mirror);
2292 // This isn't necessary since answer is the same since redefinition
2293 // has already checked this matches for the scratch class.
2432 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2433 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2434 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2435 return method->size_of_parameters();
2436 JVM_END
2437
2438
2439 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2440 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2441 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2442 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2443 return method->verifier_max_stack();
2444 JVM_END
2445
2446
2447 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2448 ResourceMark rm(THREAD);
2449 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2450 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2451 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2452 return method->name() == vmSymbols::object_initializer_name();
2453 JVM_END
2454
2455
2456 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2457 ResourceMark rm(THREAD);
2458 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2459 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2460 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2461 return method->is_overpass();
2462 JVM_END
2463
2464 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2465 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2466 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2467 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2468 return method->name()->as_utf8();
2469 JVM_END
2470
2471
2472 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3223 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3224 void* find_result = os::dll_lookup(handle, name);
3225 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3226 find_result != nullptr ? "Found" : "Failed to find",
3227 name, p2i(handle));
3228 return find_result;
3229 JVM_END
3230
3231
3232 // JNI version ///////////////////////////////////////////////////////////////////////////////
3233
3234 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3235 return Threads::is_supported_jni_version_including_1_1(version);
3236 JVM_END
3237
3238
3239 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3240 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3241 JVM_END
3242
3243 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3244 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3245 JVM_END
3246
3247 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3248 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3249 JVM_END
3250
3251 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3252 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3253 JVM_END
3254
3255 // String support ///////////////////////////////////////////////////////////////////////////
3256
3257 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3258 JvmtiVMObjectAllocEventCollector oam;
3259 if (str == nullptr) return nullptr;
3260 oop string = JNIHandles::resolve_non_null(str);
3261 oop result = StringTable::intern(string, CHECK_NULL);
3262 return (jstring) JNIHandles::make_local(THREAD, result);
3302
3303 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3304 Handle loader, jboolean throwError, TRAPS) {
3305 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3306
3307 // Check if we should initialize the class
3308 if (init && klass->is_instance_klass()) {
3309 klass->initialize(CHECK_NULL);
3310 }
3311 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3312 }
3313
3314
3315 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3316
3317 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3318 Handle method_handle;
3319 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3320 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3321 Handle receiver(THREAD, JNIHandles::resolve(obj));
3322 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3323 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3324 jobject res = JNIHandles::make_local(THREAD, result);
3325 if (JvmtiExport::should_post_vm_object_alloc()) {
3326 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3327 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3328 if (java_lang_Class::is_primitive(ret_type)) {
3329 // Only for primitive type vm allocates memory for java object.
3330 // See box() method.
3331 JvmtiExport::post_vm_object_alloc(thread, result);
3332 }
3333 }
3334 return res;
3335 } else {
3336 THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3337 }
3338 JVM_END
3339
3340
3341 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3342 oop constructor_mirror = JNIHandles::resolve(c);
3343 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3344 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3345 jobject res = JNIHandles::make_local(THREAD, result);
3346 if (JvmtiExport::should_post_vm_object_alloc()) {
3347 JvmtiExport::post_vm_object_alloc(thread, result);
3348 }
3349 return res;
3350 JVM_END
3351
3352 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3353 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3354 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3355 JVM_END
3356
3357 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3358 jclass caller,
3359 jstring interfaceMethodName,
3360 jobject factoryType,
3361 jobject interfaceMethodType,
3362 jobject implementationMember,
3363 jobject dynamicMethodType,
|
41 #include "classfile/modules.hpp"
42 #include "classfile/packageEntry.hpp"
43 #include "classfile/stringTable.hpp"
44 #include "classfile/symbolTable.hpp"
45 #include "classfile/systemDictionary.hpp"
46 #include "classfile/vmClasses.hpp"
47 #include "classfile/vmSymbols.hpp"
48 #include "gc/shared/collectedHeap.inline.hpp"
49 #include "interpreter/bytecode.hpp"
50 #include "interpreter/bytecodeUtils.hpp"
51 #include "jfr/jfrEvents.hpp"
52 #include "jvm.h"
53 #include "logging/log.hpp"
54 #include "memory/oopFactory.hpp"
55 #include "memory/referenceType.hpp"
56 #include "memory/resourceArea.hpp"
57 #include "memory/universe.hpp"
58 #include "oops/access.inline.hpp"
59 #include "oops/constantPool.hpp"
60 #include "oops/fieldStreams.inline.hpp"
61 #include "oops/flatArrayKlass.hpp"
62 #include "oops/instanceKlass.hpp"
63 #include "oops/klass.inline.hpp"
64 #include "oops/method.hpp"
65 #include "oops/recordComponent.hpp"
66 #include "oops/objArrayKlass.hpp"
67 #include "oops/objArrayOop.inline.hpp"
68 #include "oops/oop.inline.hpp"
69 #include "prims/foreignGlobals.hpp"
70 #include "prims/jvm_misc.hpp"
71 #include "prims/jvmtiExport.hpp"
72 #include "prims/jvmtiThreadState.inline.hpp"
73 #include "prims/stackwalk.hpp"
74 #include "runtime/arguments.hpp"
75 #include "runtime/atomic.hpp"
76 #include "runtime/continuation.hpp"
77 #include "runtime/globals_extension.hpp"
78 #include "runtime/handles.inline.hpp"
79 #include "runtime/init.hpp"
80 #include "runtime/interfaceSupport.inline.hpp"
81 #include "runtime/deoptimization.hpp"
397
398 return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
399 JVM_END
400
401
402 /*
403 * Return the temporary directory that the VM uses for the attach
404 * and perf data files.
405 *
406 * It is important that this directory is well-known and the
407 * same for all VM instances. It cannot be affected by configuration
408 * variables such as java.io.tmpdir.
409 */
410 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
411 HandleMark hm(THREAD);
412 const char* temp_dir = os::get_temp_directory();
413 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
414 return (jstring) JNIHandles::make_local(THREAD, h());
415 JVM_END
416
417 static void validate_array_arguments(Klass* elmClass, jint len, TRAPS) {
418 if (len < 0) {
419 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Array length is negative");
420 }
421 elmClass->initialize(CHECK);
422 if (elmClass->is_identity_class()) {
423 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not a value class");
424 }
425 if (elmClass->is_abstract()) {
426 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is abstract");
427 }
428 }
429
430 JVM_ENTRY(jarray, JVM_CopyOfSpecialArray(JNIEnv *env, jarray orig, jint from, jint to))
431 oop o = JNIHandles::resolve_non_null(orig);
432 assert(o->is_array(), "Must be");
433 oop array = nullptr;
434 arrayOop org = (arrayOop)o;
435 arrayHandle oh(THREAD, org);
436 ArrayKlass* ak = ArrayKlass::cast(org->klass());
437 InlineKlass* vk = InlineKlass::cast(ak->element_klass());
438 int len = to - from; // length of the new array
439 if (ak->is_null_free_array_klass()) {
440 if (from >= org->length() || to > org->length()) {
441 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Copying of null-free array with uninitialized elements");
442 }
443 }
444 if (org->is_flatArray()) {
445 FlatArrayKlass* fak = FlatArrayKlass::cast(org->klass());
446 LayoutKind lk = fak->layout_kind();
447 array = oopFactory::new_flatArray(vk, len, lk, CHECK_NULL);
448 arrayHandle ah(THREAD, (arrayOop)array);
449 int end = to < oh()->length() ? to : oh()->length();
450 for (int i = from; i < end; i++) {
451 void* src = ((flatArrayOop)oh())->value_at_addr(i, fak->layout_helper());
452 void* dst = ((flatArrayOop)ah())->value_at_addr(i - from, fak->layout_helper());
453 vk->copy_payload_to_addr(src, dst, lk, false);
454 }
455 array = ah();
456 } else {
457 if (org->is_null_free_array()) {
458 array = oopFactory::new_null_free_objArray(vk, len, CHECK_NULL);
459 } else {
460 array = oopFactory::new_objArray(vk, len, CHECK_NULL);
461 }
462 int end = to < oh()->length() ? to : oh()->length();
463 for (int i = from; i < end; i++) {
464 if (i < ((objArrayOop)oh())->length()) {
465 ((objArrayOop)array)->obj_at_put(i - from, ((objArrayOop)oh())->obj_at(i));
466 } else {
467 assert(!ak->is_null_free_array_klass(), "Must be a nullable array");
468 ((objArrayOop)array)->obj_at_put(i - from, nullptr);
469 }
470 }
471 }
472 return (jarray) JNIHandles::make_local(THREAD, array);
473 JVM_END
474
475 JVM_ENTRY(jarray, JVM_NewNullRestrictedNonAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal))
476 oop mirror = JNIHandles::resolve_non_null(elmClass);
477 oop init = JNIHandles::resolve(initVal);
478 if (init == nullptr) {
479 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null");
480 }
481 Handle init_h(THREAD, init);
482 Klass* klass = java_lang_Class::as_Klass(mirror);
483 if (klass != init_h()->klass()) {
484 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value");
485 }
486 validate_array_arguments(klass, len, CHECK_NULL);
487 InlineKlass* vk = InlineKlass::cast(klass);
488 oop array = nullptr;
489 if (vk->flat_array() && vk->has_non_atomic_layout()) {
490 array = oopFactory::new_flatArray(vk, len, LayoutKind::NON_ATOMIC_FLAT, CHECK_NULL);
491 for (int i = 0; i < len; i++) {
492 ((flatArrayOop)array)->write_value_to_flat_array(init_h(), i, CHECK_NULL);
493 }
494 } else {
495 array = oopFactory::new_null_free_objArray(vk, len, CHECK_NULL);
496 for (int i = 0; i < len; i++) {
497 ((objArrayOop)array)->obj_at_put(i, init_h());
498 }
499 }
500 return (jarray) JNIHandles::make_local(THREAD, array);
501 JVM_END
502
503 JVM_ENTRY(jarray, JVM_NewNullRestrictedAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal))
504 oop mirror = JNIHandles::resolve_non_null(elmClass);
505 oop init = JNIHandles::resolve(initVal);
506 if (init == nullptr) {
507 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null");
508 }
509 Handle init_h(THREAD, init);
510 Klass* klass = java_lang_Class::as_Klass(mirror);
511 if (klass != init_h()->klass()) {
512 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value");
513 }
514 validate_array_arguments(klass, len, CHECK_NULL);
515 InlineKlass* vk = InlineKlass::cast(klass);
516 oop array = nullptr;
517 if (UseArrayFlattening && vk->is_naturally_atomic() && vk->has_non_atomic_layout()) {
518 array = oopFactory::new_flatArray(vk, len, LayoutKind::NON_ATOMIC_FLAT, CHECK_NULL);
519 for (int i = 0; i < len; i++) {
520 ((flatArrayOop)array)->write_value_to_flat_array(init_h(), i, CHECK_NULL);
521 }
522 } else if (UseArrayFlattening && vk->has_atomic_layout()) {
523 array = oopFactory::new_flatArray(vk, len, LayoutKind::ATOMIC_FLAT, CHECK_NULL);
524 for (int i = 0; i < len; i++) {
525 ((flatArrayOop)array)->write_value_to_flat_array(init_h(), i, CHECK_NULL);
526 }
527 } else {
528 array = oopFactory::new_null_free_objArray(vk, len, CHECK_NULL);
529 for (int i = 0; i < len; i++) {
530 // need a type check here
531
532 ((objArrayOop)array)->obj_at_put(i, init_h());
533 }
534 }
535 return (jarray) JNIHandles::make_local(THREAD, array);
536 JVM_END
537
538 JVM_ENTRY(jarray, JVM_NewNullableAtomicArray(JNIEnv *env, jclass elmClass, jint len))
539 oop mirror = JNIHandles::resolve_non_null(elmClass);
540 Klass* klass = java_lang_Class::as_Klass(mirror);
541 klass->initialize(CHECK_NULL);
542 validate_array_arguments(klass, len, CHECK_NULL);
543 InlineKlass* vk = InlineKlass::cast(klass);
544 oop array = nullptr;
545 if (UseArrayFlattening && vk->has_nullable_atomic_layout()) {
546 array = oopFactory::new_flatArray(vk, len, LayoutKind::NULLABLE_ATOMIC_FLAT, CHECK_NULL);
547 } else {
548 array = oopFactory::new_objArray(vk, len, CHECK_NULL);
549 }
550 return (jarray) JNIHandles::make_local(THREAD, array);
551 JVM_END
552
553 JVM_ENTRY(jboolean, JVM_IsFlatArray(JNIEnv *env, jobject obj))
554 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
555 return oop->is_flatArray();
556 JVM_END
557
558 JVM_ENTRY(jboolean, JVM_IsNullRestrictedArray(JNIEnv *env, jobject obj))
559 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
560 return oop->is_null_free_array();
561 JVM_END
562
563 JVM_ENTRY(jboolean, JVM_IsAtomicArray(JNIEnv *env, jobject obj))
564 // There are multiple cases where an array can/must support atomic access:
565 // - the array is a reference array
566 // - the array uses an atomic flat layout: NULLABLE_ATOMIC_FLAT or ATOMIC_FLAT
567 // - the array is flat and its component type is naturally atomic
568 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
569 if (oop->is_objArray()) return true;
570 if (oop->is_flatArray()) {
571 FlatArrayKlass* fak = FlatArrayKlass::cast(oop->klass());
572 if (fak->layout_kind() == LayoutKind::ATOMIC_FLAT || fak->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT) {
573 return true;
574 }
575 if (fak->element_klass()->is_naturally_atomic()) return true;
576 }
577 return false;
578 JVM_END
579
580 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
581
582 extern volatile jint vm_created;
583
584 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
585 EventShutdown event;
586 if (event.should_commit()) {
587 event.set_reason("Shutdown requested from Java");
588 event.commit();
589 }
590 JVM_END
591
592
593 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
594 before_exit(thread, true);
595 vm_exit(code);
596 JVM_END
597
598
767
768 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
769 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
770 start_index, frames_array_h, THREAD);
771 JVM_END
772
773 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
774 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
775 objArrayHandle frames_array_h(THREAD, fa);
776 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
777 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
778
779 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
780 JVM_END
781
782 // java.lang.Object ///////////////////////////////////////////////
783
784
785 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
786 // as implemented in the classic virtual machine; return 0 if object is null
787 if (handle == nullptr) {
788 return 0;
789 }
790 oop obj = JNIHandles::resolve_non_null(handle);
791 if (EnableValhalla && obj->klass()->is_inline_klass()) {
792 JavaValue result(T_INT);
793 JavaCallArguments args;
794 Handle ho(THREAD, obj);
795 args.push_oop(ho);
796 methodHandle method(THREAD, Universe::value_object_hash_code_method());
797 JavaCalls::call(&result, method, &args, THREAD);
798 if (HAS_PENDING_EXCEPTION) {
799 if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
800 Handle e(THREAD, PENDING_EXCEPTION);
801 CLEAR_PENDING_EXCEPTION;
802 THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
803 }
804 }
805 return result.get_jint();
806 } else {
807 return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj));
808 }
809 JVM_END
810
811
812 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
813 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
814 ObjectSynchronizer::wait(obj, ms, CHECK);
815 JVM_END
816
817
818 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
819 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
820 ObjectSynchronizer::notify(obj, CHECK);
821 JVM_END
822
823
824 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
825 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
826 ObjectSynchronizer::notifyall(obj, CHECK);
827 JVM_END
828
836 // Just checking that the cloneable flag is set correct
837 if (obj->is_array()) {
838 guarantee(klass->is_cloneable(), "all arrays are cloneable");
839 } else {
840 guarantee(obj->is_instance(), "should be instanceOop");
841 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
842 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
843 }
844 #endif
845
846 // Check if class of obj supports the Cloneable interface.
847 // All arrays are considered to be cloneable (See JLS 20.1.5).
848 // All j.l.r.Reference classes are considered non-cloneable.
849 if (!klass->is_cloneable() ||
850 (klass->is_instance_klass() &&
851 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
852 ResourceMark rm(THREAD);
853 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
854 }
855
856 if (klass->is_inline_klass()) {
857 // Value instances have no identity, so return the current instance instead of allocating a new one
858 // Value classes cannot have finalizers, so the method can return immediately
859 return JNIHandles::make_local(THREAD, obj());
860 }
861
862 // Make shallow object copy
863 const size_t size = obj->size();
864 oop new_obj_oop = nullptr;
865 if (obj->is_array()) {
866 const int length = ((arrayOop)obj())->length();
867 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
868 /* do_zero */ true, CHECK_NULL);
869 } else {
870 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
871 }
872
873 HeapAccess<>::clone(obj(), new_obj_oop, size);
874
875 Handle new_obj(THREAD, new_obj_oop);
876 // Caution: this involves a java upcall, so the clone should be
877 // "gc-robust" by this stage.
878 if (klass->has_finalizer()) {
879 assert(obj->is_instance(), "should be instanceOop");
880 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
881 new_obj = Handle(THREAD, new_obj_oop);
1336 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1337 return (jstring) JNIHandles::make_local(THREAD, result);
1338 JVM_END
1339
1340
1341 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1342 JvmtiVMObjectAllocEventCollector oam;
1343 oop mirror = JNIHandles::resolve_non_null(cls);
1344
1345 // Special handling for primitive objects
1346 if (java_lang_Class::is_primitive(mirror)) {
1347 // Primitive objects does not have any interfaces
1348 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1349 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1350 }
1351
1352 Klass* klass = java_lang_Class::as_Klass(mirror);
1353 // Figure size of result array
1354 int size;
1355 if (klass->is_instance_klass()) {
1356 InstanceKlass* ik = InstanceKlass::cast(klass);
1357 size = ik->local_interfaces()->length();
1358 } else {
1359 assert(klass->is_objArray_klass() || klass->is_typeArray_klass() || klass->is_flatArray_klass(), "Illegal mirror klass");
1360 size = 2;
1361 }
1362
1363 // Allocate result array
1364 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1365 objArrayHandle result (THREAD, r);
1366 // Fill in result
1367 if (klass->is_instance_klass()) {
1368 // Regular instance klass, fill in all local interfaces
1369 for (int index = 0; index < size; index++) {
1370 InstanceKlass* ik = InstanceKlass::cast(klass);
1371 Klass* k = ik->local_interfaces()->at(index);
1372 result->obj_at_put(index, k->java_mirror());
1373 }
1374 } else {
1375 // All arrays implement java.lang.Cloneable and java.io.Serializable
1376 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1377 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1378 }
1379 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1380 JVM_END
1381
1382
1383 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1384 oop mirror = JNIHandles::resolve_non_null(cls);
1385 if (java_lang_Class::is_primitive(mirror)) {
1386 return JNI_FALSE;
1387 }
1388 Klass* k = java_lang_Class::as_Klass(mirror);
1389 return k->is_hidden();
1390 JVM_END
1391
1392 JVM_ENTRY(jboolean, JVM_IsIdentityClass(JNIEnv *env, jclass cls))
1393 oop mirror = JNIHandles::resolve_non_null(cls);
1394 if (java_lang_Class::is_primitive(mirror)) {
1395 return JNI_FALSE;
1396 }
1397 Klass* k = java_lang_Class::as_Klass(mirror);
1398 if (EnableValhalla) {
1399 return k->is_array_klass() || k->is_identity_class();
1400 } else {
1401 return k->is_interface() ? JNI_FALSE : JNI_TRUE;
1402 }
1403 JVM_END
1404
1405 class ScopedValueBindingsResolver {
1406 public:
1407 InstanceKlass* Carrier_klass;
1408 ScopedValueBindingsResolver(JavaThread* THREAD) {
1409 Klass *k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ScopedValue_Carrier(), true, THREAD);
1410 Carrier_klass = InstanceKlass::cast(k);
1411 }
1412 };
1413
1414 JVM_ENTRY(jobject, JVM_FindScopedValueBindings(JNIEnv *env, jclass cls))
1415 ResourceMark rm(THREAD);
1416 GrowableArray<Handle>* local_array = new GrowableArray<Handle>(12);
1417 JvmtiVMObjectAllocEventCollector oam;
1418
1419 static ScopedValueBindingsResolver resolver(THREAD);
1420
1421 // Iterate through Java frames
1422 vframeStream vfst(thread);
1423 for(; !vfst.at_end(); vfst.next()) {
1868 }
1869
1870 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1871
1872 // Ensure class is linked
1873 k->link_class(CHECK_NULL);
1874
1875 Array<Method*>* methods = k->methods();
1876 int methods_length = methods->length();
1877
1878 // Save original method_idnum in case of redefinition, which can change
1879 // the idnum of obsolete methods. The new method will have the same idnum
1880 // but if we refresh the methods array, the counts will be wrong.
1881 ResourceMark rm(THREAD);
1882 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1883 int num_methods = 0;
1884
1885 // Select methods matching the criteria.
1886 for (int i = 0; i < methods_length; i++) {
1887 Method* method = methods->at(i);
1888 if (want_constructor && !method->is_object_constructor()) {
1889 continue;
1890 }
1891 if (!want_constructor &&
1892 (method->is_object_constructor() || method->is_class_initializer() ||
1893 method->is_overpass())) {
1894 continue;
1895 }
1896 if (publicOnly && !method->is_public()) {
1897 continue;
1898 }
1899 idnums->push(method->method_idnum());
1900 ++num_methods;
1901 }
1902
1903 // Allocate result
1904 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1905 objArrayHandle result (THREAD, r);
1906
1907 // Now just put the methods that we selected above, but go by their idnum
1908 // in case of redefinition. The methods can be redefined at any safepoint,
1909 // so above when allocating the oop array and below when creating reflect
1910 // objects.
1911 for (int i = 0; i < num_methods; i++) {
1912 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1913 if (method.is_null()) {
1914 // Method may have been deleted and seems this API can handle null
1915 // Otherwise should probably put a method that throws NSME
1916 result->obj_at_put(i, nullptr);
1917 } else {
1918 oop m;
1919 if (want_constructor) {
1920 assert(method->is_object_constructor(), "must be");
1921 m = Reflection::new_constructor(method, CHECK_NULL);
1922 } else {
1923 m = Reflection::new_method(method, false, CHECK_NULL);
1924 }
1925 result->obj_at_put(i, m);
1926 }
1927 }
1928
1929 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1930 }
1931
1932 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1933 {
1934 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1935 /*want_constructor*/ false,
1936 vmClasses::reflect_Method_klass(), THREAD);
1937 }
1938 JVM_END
1939
1940 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
2183 constantTag tag = cp->tag_at(index);
2184 if (!tag.is_method() && !tag.is_interface_method()) {
2185 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2186 }
2187 int klass_ref = cp->uncached_klass_ref_index_at(index);
2188 Klass* k_o;
2189 if (force_resolution) {
2190 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2191 } else {
2192 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2193 if (k_o == nullptr) return nullptr;
2194 }
2195 InstanceKlass* k = InstanceKlass::cast(k_o);
2196 Symbol* name = cp->uncached_name_ref_at(index);
2197 Symbol* sig = cp->uncached_signature_ref_at(index);
2198 methodHandle m (THREAD, k->find_method(name, sig));
2199 if (m.is_null()) {
2200 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2201 }
2202 oop method;
2203 if (m->is_object_constructor()) {
2204 method = Reflection::new_constructor(m, CHECK_NULL);
2205 } else {
2206 method = Reflection::new_method(m, true, CHECK_NULL);
2207 }
2208 return JNIHandles::make_local(THREAD, method);
2209 }
2210
2211 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2212 {
2213 JvmtiVMObjectAllocEventCollector oam;
2214 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2215 bounds_check(cp, index, CHECK_NULL);
2216 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2217 return res;
2218 }
2219 JVM_END
2220
2221 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2222 {
2223 JvmtiVMObjectAllocEventCollector oam;
2224 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2225 bounds_check(cp, index, CHECK_NULL);
2457 Klass* k = java_lang_Class::as_Klass(r);
2458 assert(k->is_instance_klass(), "must be an instance klass");
2459 if (!k->is_instance_klass()) return false;
2460
2461 ResourceMark rm(THREAD);
2462 const char* name = k->name()->as_C_string();
2463 bool system_class = k->class_loader() == nullptr;
2464 return JavaAssertions::enabled(name, system_class);
2465
2466 JVM_END
2467
2468
2469 // Return a new AssertionStatusDirectives object with the fields filled in with
2470 // command-line assertion arguments (i.e., -ea, -da).
2471 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2472 JvmtiVMObjectAllocEventCollector oam;
2473 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2474 return JNIHandles::make_local(THREAD, asd);
2475 JVM_END
2476
2477 // Arrays support /////////////////////////////////////////////////////////////
2478
2479 JVM_ENTRY(jboolean, JVM_ArrayIsAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2480 oop o = JNIHandles::resolve(array);
2481 Klass* k = o->klass();
2482 if ((o == nullptr) || (!k->is_array_klass())) {
2483 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2484 }
2485 return ArrayKlass::cast(k)->element_access_must_be_atomic();
2486 JVM_END
2487
2488 JVM_ENTRY(jobject, JVM_ArrayEnsureAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2489 oop o = JNIHandles::resolve(array);
2490 Klass* k = o->klass();
2491 if ((o == nullptr) || (!k->is_array_klass())) {
2492 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2493 }
2494 if (k->is_flatArray_klass()) {
2495 FlatArrayKlass* vk = FlatArrayKlass::cast(k);
2496 if (!vk->element_access_must_be_atomic()) {
2497 /**
2498 * Need to decide how to implement:
2499 *
2500 * 1) Change to objArrayOop layout, therefore oop->klass() differs so
2501 * then "<atomic>[Qfoo;" klass needs to subclass "[Qfoo;" to pass through
2502 * "checkcast" & "instanceof"
2503 *
2504 * 2) Use extra header in the flatArrayOop to flag atomicity required and
2505 * possibly per instance lock structure. Said info, could be placed in
2506 * "trailer" rather than disturb the current arrayOop
2507 */
2508 Unimplemented();
2509 }
2510 }
2511 return array;
2512 JVM_END
2513
2514 // Verification ////////////////////////////////////////////////////////////////////////////////
2515
2516 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2517
2518 // RedefineClasses support: bug 6214132 caused verification to fail.
2519 // All functions from this section should call the jvmtiThreadSate function:
2520 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2521 // The function returns a Klass* of the _scratch_class if the verifier
2522 // was invoked in the middle of the class redefinition.
2523 // Otherwise it returns its argument value which is the _the_class Klass*.
2524 // Please, refer to the description in the jvmtiThreadState.hpp.
2525
2526 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
2527 oop mirror = JNIHandles::resolve_non_null(cls);
2528 if (java_lang_Class::is_primitive(mirror)) {
2529 return JNI_FALSE;
2530 }
2531 Klass* k = java_lang_Class::as_Klass(mirror);
2532 // This isn't necessary since answer is the same since redefinition
2533 // has already checked this matches for the scratch class.
2672 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2673 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2674 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2675 return method->size_of_parameters();
2676 JVM_END
2677
2678
2679 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2680 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2681 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2682 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2683 return method->verifier_max_stack();
2684 JVM_END
2685
2686
2687 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2688 ResourceMark rm(THREAD);
2689 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2690 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2691 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2692 return method->is_object_constructor();
2693 JVM_END
2694
2695
2696 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2697 ResourceMark rm(THREAD);
2698 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2699 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2700 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2701 return method->is_overpass();
2702 JVM_END
2703
2704 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2705 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2706 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2707 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2708 return method->name()->as_utf8();
2709 JVM_END
2710
2711
2712 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3463 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3464 void* find_result = os::dll_lookup(handle, name);
3465 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3466 find_result != nullptr ? "Found" : "Failed to find",
3467 name, p2i(handle));
3468 return find_result;
3469 JVM_END
3470
3471
3472 // JNI version ///////////////////////////////////////////////////////////////////////////////
3473
3474 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3475 return Threads::is_supported_jni_version_including_1_1(version);
3476 JVM_END
3477
3478
3479 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3480 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3481 JVM_END
3482
3483 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3484 return EnableValhalla ? JNI_TRUE : JNI_FALSE;
3485 JVM_END
3486
3487 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3488 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3489 JVM_END
3490
3491 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3492 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3493 JVM_END
3494
3495 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3496 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3497 JVM_END
3498
3499 // String support ///////////////////////////////////////////////////////////////////////////
3500
3501 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3502 JvmtiVMObjectAllocEventCollector oam;
3503 if (str == nullptr) return nullptr;
3504 oop string = JNIHandles::resolve_non_null(str);
3505 oop result = StringTable::intern(string, CHECK_NULL);
3506 return (jstring) JNIHandles::make_local(THREAD, result);
3546
3547 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3548 Handle loader, jboolean throwError, TRAPS) {
3549 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3550
3551 // Check if we should initialize the class
3552 if (init && klass->is_instance_klass()) {
3553 klass->initialize(CHECK_NULL);
3554 }
3555 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3556 }
3557
3558
3559 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3560
3561 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3562 Handle method_handle;
3563 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3564 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3565 Handle receiver(THREAD, JNIHandles::resolve(obj));
3566 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3567 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3568 jobject res = JNIHandles::make_local(THREAD, result);
3569 if (JvmtiExport::should_post_vm_object_alloc()) {
3570 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3571 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3572 if (java_lang_Class::is_primitive(ret_type)) {
3573 // Only for primitive type vm allocates memory for java object.
3574 // See box() method.
3575 JvmtiExport::post_vm_object_alloc(thread, result);
3576 }
3577 }
3578 return res;
3579 } else {
3580 THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3581 }
3582 JVM_END
3583
3584
3585 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3586 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3587 oop constructor_mirror = JNIHandles::resolve(c);
3588 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3589 jobject res = JNIHandles::make_local(THREAD, result);
3590 if (JvmtiExport::should_post_vm_object_alloc()) {
3591 JvmtiExport::post_vm_object_alloc(thread, result);
3592 }
3593 return res;
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 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3599 JVM_END
3600
3601 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3602 jclass caller,
3603 jstring interfaceMethodName,
3604 jobject factoryType,
3605 jobject interfaceMethodType,
3606 jobject implementationMember,
3607 jobject dynamicMethodType,
|