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"
394
395 return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
396 JVM_END
397
398
399 /*
400 * Return the temporary directory that the VM uses for the attach
401 * and perf data files.
402 *
403 * It is important that this directory is well-known and the
404 * same for all VM instances. It cannot be affected by configuration
405 * variables such as java.io.tmpdir.
406 */
407 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
408 HandleMark hm(THREAD);
409 const char* temp_dir = os::get_temp_directory();
410 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
411 return (jstring) JNIHandles::make_local(THREAD, h());
412 JVM_END
413
414
415 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
416
417 extern volatile jint vm_created;
418
419 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
420 EventShutdown event;
421 if (event.should_commit()) {
422 event.set_reason("Shutdown requested from Java");
423 event.commit();
424 }
425 JVM_END
426
427
428 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
429 before_exit(thread, true);
430 vm_exit(code);
431 JVM_END
432
433
602
603 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
604 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
605 start_index, frames_array_h, THREAD);
606 JVM_END
607
608 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
609 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
610 objArrayHandle frames_array_h(THREAD, fa);
611 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
612 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
613
614 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
615 JVM_END
616
617 // java.lang.Object ///////////////////////////////////////////////
618
619
620 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
621 // as implemented in the classic virtual machine; return 0 if object is null
622 return handle == nullptr ? 0 :
623 checked_cast<jint>(ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)));
624 JVM_END
625
626
627 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
628 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
629 ObjectSynchronizer::wait(obj, ms, CHECK);
630 JVM_END
631
632
633 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
634 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
635 ObjectSynchronizer::notify(obj, CHECK);
636 JVM_END
637
638
639 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
640 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
641 ObjectSynchronizer::notifyall(obj, CHECK);
642 JVM_END
643
651 // Just checking that the cloneable flag is set correct
652 if (obj->is_array()) {
653 guarantee(klass->is_cloneable(), "all arrays are cloneable");
654 } else {
655 guarantee(obj->is_instance(), "should be instanceOop");
656 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
657 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
658 }
659 #endif
660
661 // Check if class of obj supports the Cloneable interface.
662 // All arrays are considered to be cloneable (See JLS 20.1.5).
663 // All j.l.r.Reference classes are considered non-cloneable.
664 if (!klass->is_cloneable() ||
665 (klass->is_instance_klass() &&
666 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
667 ResourceMark rm(THREAD);
668 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
669 }
670
671 // Make shallow object copy
672 const size_t size = obj->size();
673 oop new_obj_oop = nullptr;
674 if (obj->is_array()) {
675 const int length = ((arrayOop)obj())->length();
676 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
677 /* do_zero */ true, CHECK_NULL);
678 } else {
679 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
680 }
681
682 HeapAccess<>::clone(obj(), new_obj_oop, size);
683
684 Handle new_obj(THREAD, new_obj_oop);
685 // Caution: this involves a java upcall, so the clone should be
686 // "gc-robust" by this stage.
687 if (klass->has_finalizer()) {
688 assert(obj->is_instance(), "should be instanceOop");
689 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
690 new_obj = Handle(THREAD, new_obj_oop);
1145 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1146 return (jstring) JNIHandles::make_local(THREAD, result);
1147 JVM_END
1148
1149
1150 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1151 JvmtiVMObjectAllocEventCollector oam;
1152 oop mirror = JNIHandles::resolve_non_null(cls);
1153
1154 // Special handling for primitive objects
1155 if (java_lang_Class::is_primitive(mirror)) {
1156 // Primitive objects does not have any interfaces
1157 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1158 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1159 }
1160
1161 Klass* klass = java_lang_Class::as_Klass(mirror);
1162 // Figure size of result array
1163 int size;
1164 if (klass->is_instance_klass()) {
1165 size = InstanceKlass::cast(klass)->local_interfaces()->length();
1166 } else {
1167 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1168 size = 2;
1169 }
1170
1171 // Allocate result array
1172 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1173 objArrayHandle result (THREAD, r);
1174 // Fill in result
1175 if (klass->is_instance_klass()) {
1176 // Regular instance klass, fill in all local interfaces
1177 for (int index = 0; index < size; index++) {
1178 Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1179 result->obj_at_put(index, k->java_mirror());
1180 }
1181 } else {
1182 // All arrays implement java.lang.Cloneable and java.io.Serializable
1183 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1184 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1185 }
1186 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1187 JVM_END
1188
1189
1190 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1191 oop mirror = JNIHandles::resolve_non_null(cls);
1192 if (java_lang_Class::is_primitive(mirror)) {
1193 return JNI_FALSE;
1194 }
1195 Klass* k = java_lang_Class::as_Klass(mirror);
1196 return k->is_hidden();
1197 JVM_END
1198
1199
1200 class ScopedValueBindingsResolver {
1201 public:
1202 InstanceKlass* Carrier_klass;
1203 ScopedValueBindingsResolver(JavaThread* THREAD) {
1204 Klass *k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ScopedValue_Carrier(), true, THREAD);
1205 Carrier_klass = InstanceKlass::cast(k);
1206 }
1207 };
1208
1209 JVM_ENTRY(jobject, JVM_FindScopedValueBindings(JNIEnv *env, jclass cls))
1210 ResourceMark rm(THREAD);
1211 GrowableArray<Handle>* local_array = new GrowableArray<Handle>(12);
1212 JvmtiVMObjectAllocEventCollector oam;
1213
1214 static ScopedValueBindingsResolver resolver(THREAD);
1215
1216 // Iterate through Java frames
1217 vframeStream vfst(thread);
1218 for(; !vfst.at_end(); vfst.next()) {
1663 }
1664
1665 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1666
1667 // Ensure class is linked
1668 k->link_class(CHECK_NULL);
1669
1670 Array<Method*>* methods = k->methods();
1671 int methods_length = methods->length();
1672
1673 // Save original method_idnum in case of redefinition, which can change
1674 // the idnum of obsolete methods. The new method will have the same idnum
1675 // but if we refresh the methods array, the counts will be wrong.
1676 ResourceMark rm(THREAD);
1677 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1678 int num_methods = 0;
1679
1680 // Select methods matching the criteria.
1681 for (int i = 0; i < methods_length; i++) {
1682 Method* method = methods->at(i);
1683 if (want_constructor && !method->is_object_initializer()) {
1684 continue;
1685 }
1686 if (!want_constructor &&
1687 (method->is_object_initializer() || method->is_static_initializer() ||
1688 method->is_overpass())) {
1689 continue;
1690 }
1691 if (publicOnly && !method->is_public()) {
1692 continue;
1693 }
1694 idnums->push(method->method_idnum());
1695 ++num_methods;
1696 }
1697
1698 // Allocate result
1699 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1700 objArrayHandle result (THREAD, r);
1701
1702 // Now just put the methods that we selected above, but go by their idnum
1703 // in case of redefinition. The methods can be redefined at any safepoint,
1704 // so above when allocating the oop array and below when creating reflect
1705 // objects.
1706 for (int i = 0; i < num_methods; i++) {
1707 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1708 if (method.is_null()) {
1709 // Method may have been deleted and seems this API can handle null
1710 // Otherwise should probably put a method that throws NSME
1711 result->obj_at_put(i, nullptr);
1712 } else {
1713 oop m;
1714 if (want_constructor) {
1715 m = Reflection::new_constructor(method, CHECK_NULL);
1716 } else {
1717 m = Reflection::new_method(method, false, CHECK_NULL);
1718 }
1719 result->obj_at_put(i, m);
1720 }
1721 }
1722
1723 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1724 }
1725
1726 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1727 {
1728 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1729 /*want_constructor*/ false,
1730 vmClasses::reflect_Method_klass(), THREAD);
1731 }
1732 JVM_END
1733
1734 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1977 constantTag tag = cp->tag_at(index);
1978 if (!tag.is_method() && !tag.is_interface_method()) {
1979 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
1980 }
1981 int klass_ref = cp->uncached_klass_ref_index_at(index);
1982 Klass* k_o;
1983 if (force_resolution) {
1984 k_o = cp->klass_at(klass_ref, CHECK_NULL);
1985 } else {
1986 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
1987 if (k_o == nullptr) return nullptr;
1988 }
1989 InstanceKlass* k = InstanceKlass::cast(k_o);
1990 Symbol* name = cp->uncached_name_ref_at(index);
1991 Symbol* sig = cp->uncached_signature_ref_at(index);
1992 methodHandle m (THREAD, k->find_method(name, sig));
1993 if (m.is_null()) {
1994 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
1995 }
1996 oop method;
1997 if (m->is_object_initializer()) {
1998 method = Reflection::new_constructor(m, CHECK_NULL);
1999 } else {
2000 // new_method accepts <clinit> as Method here
2001 method = Reflection::new_method(m, true, CHECK_NULL);
2002 }
2003 return JNIHandles::make_local(THREAD, method);
2004 }
2005
2006 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2007 {
2008 JvmtiVMObjectAllocEventCollector oam;
2009 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2010 bounds_check(cp, index, CHECK_NULL);
2011 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2012 return res;
2013 }
2014 JVM_END
2015
2016 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2017 {
2018 JvmtiVMObjectAllocEventCollector oam;
2019 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2020 bounds_check(cp, index, CHECK_NULL);
2252 Klass* k = java_lang_Class::as_Klass(r);
2253 assert(k->is_instance_klass(), "must be an instance klass");
2254 if (!k->is_instance_klass()) return false;
2255
2256 ResourceMark rm(THREAD);
2257 const char* name = k->name()->as_C_string();
2258 bool system_class = k->class_loader() == nullptr;
2259 return JavaAssertions::enabled(name, system_class);
2260
2261 JVM_END
2262
2263
2264 // Return a new AssertionStatusDirectives object with the fields filled in with
2265 // command-line assertion arguments (i.e., -ea, -da).
2266 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2267 JvmtiVMObjectAllocEventCollector oam;
2268 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2269 return JNIHandles::make_local(THREAD, asd);
2270 JVM_END
2271
2272 // Verification ////////////////////////////////////////////////////////////////////////////////
2273
2274 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2275
2276 // RedefineClasses support: bug 6214132 caused verification to fail.
2277 // All functions from this section should call the jvmtiThreadSate function:
2278 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2279 // The function returns a Klass* of the _scratch_class if the verifier
2280 // was invoked in the middle of the class redefinition.
2281 // Otherwise it returns its argument value which is the _the_class Klass*.
2282 // Please, refer to the description in the jvmtiThreadState.hpp.
2283
2284 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
2285 oop mirror = JNIHandles::resolve_non_null(cls);
2286 if (java_lang_Class::is_primitive(mirror)) {
2287 return JNI_FALSE;
2288 }
2289 Klass* k = java_lang_Class::as_Klass(mirror);
2290 // This isn't necessary since answer is the same since redefinition
2291 // has already checked this matches for the scratch class.
2430 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2431 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2432 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2433 return method->size_of_parameters();
2434 JVM_END
2435
2436
2437 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2438 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2439 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2440 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2441 return method->verifier_max_stack();
2442 JVM_END
2443
2444
2445 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2446 ResourceMark rm(THREAD);
2447 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2448 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2449 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2450 return method->name() == vmSymbols::object_initializer_name();
2451 JVM_END
2452
2453
2454 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2455 ResourceMark rm(THREAD);
2456 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2457 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2458 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2459 return method->is_overpass();
2460 JVM_END
2461
2462 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2463 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2464 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2465 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2466 return method->name()->as_utf8();
2467 JVM_END
2468
2469
2470 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3221 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3222 void* find_result = os::dll_lookup(handle, name);
3223 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3224 find_result != nullptr ? "Found" : "Failed to find",
3225 name, p2i(handle));
3226 return find_result;
3227 JVM_END
3228
3229
3230 // JNI version ///////////////////////////////////////////////////////////////////////////////
3231
3232 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3233 return Threads::is_supported_jni_version_including_1_1(version);
3234 JVM_END
3235
3236
3237 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3238 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3239 JVM_END
3240
3241 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3242 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3243 JVM_END
3244
3245 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3246 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3247 JVM_END
3248
3249 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3250 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3251 JVM_END
3252
3253 // String support ///////////////////////////////////////////////////////////////////////////
3254
3255 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3256 JvmtiVMObjectAllocEventCollector oam;
3257 if (str == nullptr) return nullptr;
3258 oop string = JNIHandles::resolve_non_null(str);
3259 oop result = StringTable::intern(string, CHECK_NULL);
3260 return (jstring) JNIHandles::make_local(THREAD, result);
3300
3301 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3302 Handle loader, jboolean throwError, TRAPS) {
3303 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3304
3305 // Check if we should initialize the class
3306 if (init && klass->is_instance_klass()) {
3307 klass->initialize(CHECK_NULL);
3308 }
3309 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3310 }
3311
3312
3313 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3314
3315 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3316 Handle method_handle;
3317 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3318 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3319 Handle receiver(THREAD, JNIHandles::resolve(obj));
3320 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3321 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3322 jobject res = JNIHandles::make_local(THREAD, result);
3323 if (JvmtiExport::should_post_vm_object_alloc()) {
3324 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3325 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3326 if (java_lang_Class::is_primitive(ret_type)) {
3327 // Only for primitive type vm allocates memory for java object.
3328 // See box() method.
3329 JvmtiExport::post_vm_object_alloc(thread, result);
3330 }
3331 }
3332 return res;
3333 } else {
3334 THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3335 }
3336 JVM_END
3337
3338
3339 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3340 oop constructor_mirror = JNIHandles::resolve(c);
3341 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3342 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3343 jobject res = JNIHandles::make_local(THREAD, result);
3344 if (JvmtiExport::should_post_vm_object_alloc()) {
3345 JvmtiExport::post_vm_object_alloc(thread, result);
3346 }
3347 return res;
3348 JVM_END
3349
3350 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3351 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3352 assert(k->is_klass(), "just checking");
3353 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3354 JVM_END
3355
3356 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3357 jclass caller,
3358 jstring interfaceMethodName,
3359 jobject factoryType,
3360 jobject interfaceMethodType,
3361 jobject implementationMember,
|
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"
395
396 return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
397 JVM_END
398
399
400 /*
401 * Return the temporary directory that the VM uses for the attach
402 * and perf data files.
403 *
404 * It is important that this directory is well-known and the
405 * same for all VM instances. It cannot be affected by configuration
406 * variables such as java.io.tmpdir.
407 */
408 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
409 HandleMark hm(THREAD);
410 const char* temp_dir = os::get_temp_directory();
411 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
412 return (jstring) JNIHandles::make_local(THREAD, h());
413 JVM_END
414
415 static void validate_array_arguments(Klass* elmClass, jint len, TRAPS) {
416 if (len < 0) {
417 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Array length is negative");
418 }
419 elmClass->initialize(CHECK);
420 if (elmClass->is_identity_class()) {
421 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not a value class");
422 }
423 if (elmClass->is_abstract()) {
424 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is abstract");
425 }
426 }
427
428 JVM_ENTRY(jarray, JVM_NewNullRestrictedArray(JNIEnv *env, jclass elmClass, jint len))
429 oop mirror = JNIHandles::resolve_non_null(elmClass);
430 Klass* klass = java_lang_Class::as_Klass(mirror);
431 klass->initialize(CHECK_NULL);
432 validate_array_arguments(klass, len, CHECK_NULL);
433 InlineKlass* vk = InlineKlass::cast(klass);
434 if (!vk->is_implicitly_constructible()) {
435 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not implicitly constructible");
436 }
437 oop array = nullptr;
438 if (vk->flat_array() && vk->has_non_atomic_layout()) {
439 array = oopFactory::new_flatArray(vk, len, LayoutKind::NON_ATOMIC_FLAT, CHECK_NULL);
440 } else {
441 array = oopFactory::new_null_free_objArray(vk, len, CHECK_NULL);
442 }
443 return (jarray) JNIHandles::make_local(THREAD, array);
444 JVM_END
445
446 JVM_ENTRY(jarray, JVM_NewNullRestrictedAtomicArray(JNIEnv *env, jclass elmClass, jint len))
447 oop mirror = JNIHandles::resolve_non_null(elmClass);
448 Klass* klass = java_lang_Class::as_Klass(mirror);
449 klass->initialize(CHECK_NULL);
450 validate_array_arguments(klass, len, CHECK_NULL);
451 InlineKlass* vk = InlineKlass::cast(klass);
452 if (!vk->is_implicitly_constructible()) {
453 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not implicitly constructible");
454 }
455 oop array = nullptr;
456 if (UseArrayFlattening && vk->is_naturally_atomic() && vk->has_non_atomic_layout()) {
457 array = oopFactory::new_flatArray(vk, len, LayoutKind::NON_ATOMIC_FLAT, CHECK_NULL);
458 } else if (UseArrayFlattening && vk->has_atomic_layout()) {
459 array = oopFactory::new_flatArray(vk, len, LayoutKind::ATOMIC_FLAT, CHECK_NULL);
460 } else {
461 array = oopFactory::new_null_free_objArray(vk, len, CHECK_NULL);
462 }
463 return (jarray) JNIHandles::make_local(THREAD, array);
464 JVM_END
465
466 JVM_ENTRY(jarray, JVM_NewNullableAtomicArray(JNIEnv *env, jclass elmClass, jint len))
467 oop mirror = JNIHandles::resolve_non_null(elmClass);
468 Klass* klass = java_lang_Class::as_Klass(mirror);
469 klass->initialize(CHECK_NULL);
470 validate_array_arguments(klass, len, CHECK_NULL);
471 InlineKlass* vk = InlineKlass::cast(klass);
472 oop array = nullptr;
473 if (UseArrayFlattening && vk->has_nullable_atomic_layout()) {
474 array = oopFactory::new_flatArray(vk, len, LayoutKind::NULLABLE_ATOMIC_FLAT, CHECK_NULL);
475 } else {
476 array = oopFactory::new_objArray(vk, len, CHECK_NULL);
477 }
478 return (jarray) JNIHandles::make_local(THREAD, array);
479 JVM_END
480
481 JVM_ENTRY(jboolean, JVM_IsFlatArray(JNIEnv *env, jobject obj))
482 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
483 return oop->is_flatArray();
484 JVM_END
485
486 JVM_ENTRY(jboolean, JVM_IsNullRestrictedArray(JNIEnv *env, jobject obj))
487 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
488 return oop->is_null_free_array();
489 JVM_END
490
491 JVM_ENTRY(jboolean, JVM_IsAtomicArray(JNIEnv *env, jobject obj))
492 // There are multiple cases where an array can/must support atomic access:
493 // - the array is a reference array
494 // - the array uses an atomic flat layout: NULLABLE_ATOMIC_FLAT or ATOMIC_FLAT
495 // - the array is flat and its component type is naturally atomic
496 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
497 if (oop->is_objArray()) return true;
498 if (oop->is_flatArray()) {
499 FlatArrayKlass* fak = FlatArrayKlass::cast(oop->klass());
500 if (fak->layout_kind() == LayoutKind::ATOMIC_FLAT || fak->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT) {
501 return true;
502 }
503 if (fak->element_klass()->is_naturally_atomic()) return true;
504 }
505 return false;
506 JVM_END
507
508 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
509
510 extern volatile jint vm_created;
511
512 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
513 EventShutdown event;
514 if (event.should_commit()) {
515 event.set_reason("Shutdown requested from Java");
516 event.commit();
517 }
518 JVM_END
519
520
521 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
522 before_exit(thread, true);
523 vm_exit(code);
524 JVM_END
525
526
695
696 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
697 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
698 start_index, frames_array_h, THREAD);
699 JVM_END
700
701 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
702 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
703 objArrayHandle frames_array_h(THREAD, fa);
704 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
705 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
706
707 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
708 JVM_END
709
710 // java.lang.Object ///////////////////////////////////////////////
711
712
713 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
714 // as implemented in the classic virtual machine; return 0 if object is null
715 if (handle == nullptr) {
716 return 0;
717 }
718 oop obj = JNIHandles::resolve_non_null(handle);
719 if (EnableValhalla && obj->klass()->is_inline_klass()) {
720 JavaValue result(T_INT);
721 JavaCallArguments args;
722 Handle ho(THREAD, obj);
723 args.push_oop(ho);
724 methodHandle method(THREAD, Universe::value_object_hash_code_method());
725 JavaCalls::call(&result, method, &args, THREAD);
726 if (HAS_PENDING_EXCEPTION) {
727 if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
728 Handle e(THREAD, PENDING_EXCEPTION);
729 CLEAR_PENDING_EXCEPTION;
730 THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
731 }
732 }
733 return result.get_jint();
734 } else {
735 return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj));
736 }
737 JVM_END
738
739
740 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
741 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
742 ObjectSynchronizer::wait(obj, ms, CHECK);
743 JVM_END
744
745
746 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
747 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
748 ObjectSynchronizer::notify(obj, CHECK);
749 JVM_END
750
751
752 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
753 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
754 ObjectSynchronizer::notifyall(obj, CHECK);
755 JVM_END
756
764 // Just checking that the cloneable flag is set correct
765 if (obj->is_array()) {
766 guarantee(klass->is_cloneable(), "all arrays are cloneable");
767 } else {
768 guarantee(obj->is_instance(), "should be instanceOop");
769 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
770 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
771 }
772 #endif
773
774 // Check if class of obj supports the Cloneable interface.
775 // All arrays are considered to be cloneable (See JLS 20.1.5).
776 // All j.l.r.Reference classes are considered non-cloneable.
777 if (!klass->is_cloneable() ||
778 (klass->is_instance_klass() &&
779 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
780 ResourceMark rm(THREAD);
781 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
782 }
783
784 if (klass->is_inline_klass()) {
785 // Value instances have no identity, so return the current instance instead of allocating a new one
786 // Value classes cannot have finalizers, so the method can return immediately
787 return JNIHandles::make_local(THREAD, obj());
788 }
789
790 // Make shallow object copy
791 const size_t size = obj->size();
792 oop new_obj_oop = nullptr;
793 if (obj->is_array()) {
794 const int length = ((arrayOop)obj())->length();
795 new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
796 /* do_zero */ true, CHECK_NULL);
797 } else {
798 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
799 }
800
801 HeapAccess<>::clone(obj(), new_obj_oop, size);
802
803 Handle new_obj(THREAD, new_obj_oop);
804 // Caution: this involves a java upcall, so the clone should be
805 // "gc-robust" by this stage.
806 if (klass->has_finalizer()) {
807 assert(obj->is_instance(), "should be instanceOop");
808 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
809 new_obj = Handle(THREAD, new_obj_oop);
1264 oop result = java_lang_Class::name(java_class, CHECK_NULL);
1265 return (jstring) JNIHandles::make_local(THREAD, result);
1266 JVM_END
1267
1268
1269 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1270 JvmtiVMObjectAllocEventCollector oam;
1271 oop mirror = JNIHandles::resolve_non_null(cls);
1272
1273 // Special handling for primitive objects
1274 if (java_lang_Class::is_primitive(mirror)) {
1275 // Primitive objects does not have any interfaces
1276 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1277 return (jobjectArray) JNIHandles::make_local(THREAD, r);
1278 }
1279
1280 Klass* klass = java_lang_Class::as_Klass(mirror);
1281 // Figure size of result array
1282 int size;
1283 if (klass->is_instance_klass()) {
1284 InstanceKlass* ik = InstanceKlass::cast(klass);
1285 size = ik->local_interfaces()->length();
1286 } else {
1287 assert(klass->is_objArray_klass() || klass->is_typeArray_klass() || klass->is_flatArray_klass(), "Illegal mirror klass");
1288 size = 2;
1289 }
1290
1291 // Allocate result array
1292 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1293 objArrayHandle result (THREAD, r);
1294 // Fill in result
1295 if (klass->is_instance_klass()) {
1296 // Regular instance klass, fill in all local interfaces
1297 for (int index = 0; index < size; index++) {
1298 InstanceKlass* ik = InstanceKlass::cast(klass);
1299 Klass* k = ik->local_interfaces()->at(index);
1300 result->obj_at_put(index, k->java_mirror());
1301 }
1302 } else {
1303 // All arrays implement java.lang.Cloneable and java.io.Serializable
1304 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1305 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1306 }
1307 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1308 JVM_END
1309
1310
1311 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1312 oop mirror = JNIHandles::resolve_non_null(cls);
1313 if (java_lang_Class::is_primitive(mirror)) {
1314 return JNI_FALSE;
1315 }
1316 Klass* k = java_lang_Class::as_Klass(mirror);
1317 return k->is_hidden();
1318 JVM_END
1319
1320 JVM_ENTRY(jboolean, JVM_IsIdentityClass(JNIEnv *env, jclass cls))
1321 oop mirror = JNIHandles::resolve_non_null(cls);
1322 if (java_lang_Class::is_primitive(mirror)) {
1323 return JNI_FALSE;
1324 }
1325 Klass* k = java_lang_Class::as_Klass(mirror);
1326 if (EnableValhalla) {
1327 return k->is_array_klass() || k->is_identity_class();
1328 } else {
1329 return k->is_interface() ? JNI_FALSE : JNI_TRUE;
1330 }
1331 JVM_END
1332
1333 JVM_ENTRY(jboolean, JVM_IsImplicitlyConstructibleClass(JNIEnv *env, jclass cls))
1334 oop mirror = JNIHandles::resolve_non_null(cls);
1335 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
1336 return ik->is_implicitly_constructible();
1337 JVM_END
1338
1339
1340 class ScopedValueBindingsResolver {
1341 public:
1342 InstanceKlass* Carrier_klass;
1343 ScopedValueBindingsResolver(JavaThread* THREAD) {
1344 Klass *k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ScopedValue_Carrier(), true, THREAD);
1345 Carrier_klass = InstanceKlass::cast(k);
1346 }
1347 };
1348
1349 JVM_ENTRY(jobject, JVM_FindScopedValueBindings(JNIEnv *env, jclass cls))
1350 ResourceMark rm(THREAD);
1351 GrowableArray<Handle>* local_array = new GrowableArray<Handle>(12);
1352 JvmtiVMObjectAllocEventCollector oam;
1353
1354 static ScopedValueBindingsResolver resolver(THREAD);
1355
1356 // Iterate through Java frames
1357 vframeStream vfst(thread);
1358 for(; !vfst.at_end(); vfst.next()) {
1803 }
1804
1805 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1806
1807 // Ensure class is linked
1808 k->link_class(CHECK_NULL);
1809
1810 Array<Method*>* methods = k->methods();
1811 int methods_length = methods->length();
1812
1813 // Save original method_idnum in case of redefinition, which can change
1814 // the idnum of obsolete methods. The new method will have the same idnum
1815 // but if we refresh the methods array, the counts will be wrong.
1816 ResourceMark rm(THREAD);
1817 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1818 int num_methods = 0;
1819
1820 // Select methods matching the criteria.
1821 for (int i = 0; i < methods_length; i++) {
1822 Method* method = methods->at(i);
1823 if (want_constructor && !method->is_object_constructor()) {
1824 continue;
1825 }
1826 if (!want_constructor &&
1827 (method->is_object_constructor() || method->is_class_initializer() ||
1828 method->is_overpass())) {
1829 continue;
1830 }
1831 if (publicOnly && !method->is_public()) {
1832 continue;
1833 }
1834 idnums->push(method->method_idnum());
1835 ++num_methods;
1836 }
1837
1838 // Allocate result
1839 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1840 objArrayHandle result (THREAD, r);
1841
1842 // Now just put the methods that we selected above, but go by their idnum
1843 // in case of redefinition. The methods can be redefined at any safepoint,
1844 // so above when allocating the oop array and below when creating reflect
1845 // objects.
1846 for (int i = 0; i < num_methods; i++) {
1847 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1848 if (method.is_null()) {
1849 // Method may have been deleted and seems this API can handle null
1850 // Otherwise should probably put a method that throws NSME
1851 result->obj_at_put(i, nullptr);
1852 } else {
1853 oop m;
1854 if (want_constructor) {
1855 assert(method->is_object_constructor(), "must be");
1856 m = Reflection::new_constructor(method, CHECK_NULL);
1857 } else {
1858 m = Reflection::new_method(method, false, CHECK_NULL);
1859 }
1860 result->obj_at_put(i, m);
1861 }
1862 }
1863
1864 return (jobjectArray) JNIHandles::make_local(THREAD, result());
1865 }
1866
1867 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1868 {
1869 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1870 /*want_constructor*/ false,
1871 vmClasses::reflect_Method_klass(), THREAD);
1872 }
1873 JVM_END
1874
1875 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
2118 constantTag tag = cp->tag_at(index);
2119 if (!tag.is_method() && !tag.is_interface_method()) {
2120 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2121 }
2122 int klass_ref = cp->uncached_klass_ref_index_at(index);
2123 Klass* k_o;
2124 if (force_resolution) {
2125 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2126 } else {
2127 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2128 if (k_o == nullptr) return nullptr;
2129 }
2130 InstanceKlass* k = InstanceKlass::cast(k_o);
2131 Symbol* name = cp->uncached_name_ref_at(index);
2132 Symbol* sig = cp->uncached_signature_ref_at(index);
2133 methodHandle m (THREAD, k->find_method(name, sig));
2134 if (m.is_null()) {
2135 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2136 }
2137 oop method;
2138 if (m->is_object_constructor()) {
2139 method = Reflection::new_constructor(m, CHECK_NULL);
2140 } else {
2141 method = Reflection::new_method(m, true, CHECK_NULL);
2142 }
2143 return JNIHandles::make_local(THREAD, method);
2144 }
2145
2146 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2147 {
2148 JvmtiVMObjectAllocEventCollector oam;
2149 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2150 bounds_check(cp, index, CHECK_NULL);
2151 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2152 return res;
2153 }
2154 JVM_END
2155
2156 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2157 {
2158 JvmtiVMObjectAllocEventCollector oam;
2159 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2160 bounds_check(cp, index, CHECK_NULL);
2392 Klass* k = java_lang_Class::as_Klass(r);
2393 assert(k->is_instance_klass(), "must be an instance klass");
2394 if (!k->is_instance_klass()) return false;
2395
2396 ResourceMark rm(THREAD);
2397 const char* name = k->name()->as_C_string();
2398 bool system_class = k->class_loader() == nullptr;
2399 return JavaAssertions::enabled(name, system_class);
2400
2401 JVM_END
2402
2403
2404 // Return a new AssertionStatusDirectives object with the fields filled in with
2405 // command-line assertion arguments (i.e., -ea, -da).
2406 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2407 JvmtiVMObjectAllocEventCollector oam;
2408 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2409 return JNIHandles::make_local(THREAD, asd);
2410 JVM_END
2411
2412 // Arrays support /////////////////////////////////////////////////////////////
2413
2414 JVM_ENTRY(jboolean, JVM_ArrayIsAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2415 oop o = JNIHandles::resolve(array);
2416 Klass* k = o->klass();
2417 if ((o == nullptr) || (!k->is_array_klass())) {
2418 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2419 }
2420 return ArrayKlass::cast(k)->element_access_must_be_atomic();
2421 JVM_END
2422
2423 JVM_ENTRY(jobject, JVM_ArrayEnsureAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2424 oop o = JNIHandles::resolve(array);
2425 Klass* k = o->klass();
2426 if ((o == nullptr) || (!k->is_array_klass())) {
2427 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2428 }
2429 if (k->is_flatArray_klass()) {
2430 FlatArrayKlass* vk = FlatArrayKlass::cast(k);
2431 if (!vk->element_access_must_be_atomic()) {
2432 /**
2433 * Need to decide how to implement:
2434 *
2435 * 1) Change to objArrayOop layout, therefore oop->klass() differs so
2436 * then "<atomic>[Qfoo;" klass needs to subclass "[Qfoo;" to pass through
2437 * "checkcast" & "instanceof"
2438 *
2439 * 2) Use extra header in the flatArrayOop to flag atomicity required and
2440 * possibly per instance lock structure. Said info, could be placed in
2441 * "trailer" rather than disturb the current arrayOop
2442 */
2443 Unimplemented();
2444 }
2445 }
2446 return array;
2447 JVM_END
2448
2449 // Verification ////////////////////////////////////////////////////////////////////////////////
2450
2451 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2452
2453 // RedefineClasses support: bug 6214132 caused verification to fail.
2454 // All functions from this section should call the jvmtiThreadSate function:
2455 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2456 // The function returns a Klass* of the _scratch_class if the verifier
2457 // was invoked in the middle of the class redefinition.
2458 // Otherwise it returns its argument value which is the _the_class Klass*.
2459 // Please, refer to the description in the jvmtiThreadState.hpp.
2460
2461 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
2462 oop mirror = JNIHandles::resolve_non_null(cls);
2463 if (java_lang_Class::is_primitive(mirror)) {
2464 return JNI_FALSE;
2465 }
2466 Klass* k = java_lang_Class::as_Klass(mirror);
2467 // This isn't necessary since answer is the same since redefinition
2468 // has already checked this matches for the scratch class.
2607 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2608 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2609 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2610 return method->size_of_parameters();
2611 JVM_END
2612
2613
2614 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2615 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2616 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2617 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2618 return method->verifier_max_stack();
2619 JVM_END
2620
2621
2622 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2623 ResourceMark rm(THREAD);
2624 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2625 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2626 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2627 return method->is_object_constructor();
2628 JVM_END
2629
2630
2631 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2632 ResourceMark rm(THREAD);
2633 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2634 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2635 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2636 return method->is_overpass();
2637 JVM_END
2638
2639 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2640 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2641 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2642 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2643 return method->name()->as_utf8();
2644 JVM_END
2645
2646
2647 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
3398 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3399 void* find_result = os::dll_lookup(handle, name);
3400 log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3401 find_result != nullptr ? "Found" : "Failed to find",
3402 name, p2i(handle));
3403 return find_result;
3404 JVM_END
3405
3406
3407 // JNI version ///////////////////////////////////////////////////////////////////////////////
3408
3409 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3410 return Threads::is_supported_jni_version_including_1_1(version);
3411 JVM_END
3412
3413
3414 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3415 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3416 JVM_END
3417
3418 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3419 return EnableValhalla ? JNI_TRUE : JNI_FALSE;
3420 JVM_END
3421
3422 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3423 return VMContinuations ? JNI_TRUE : JNI_FALSE;
3424 JVM_END
3425
3426 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3427 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3428 JVM_END
3429
3430 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3431 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3432 JVM_END
3433
3434 // String support ///////////////////////////////////////////////////////////////////////////
3435
3436 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3437 JvmtiVMObjectAllocEventCollector oam;
3438 if (str == nullptr) return nullptr;
3439 oop string = JNIHandles::resolve_non_null(str);
3440 oop result = StringTable::intern(string, CHECK_NULL);
3441 return (jstring) JNIHandles::make_local(THREAD, result);
3481
3482 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3483 Handle loader, jboolean throwError, TRAPS) {
3484 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3485
3486 // Check if we should initialize the class
3487 if (init && klass->is_instance_klass()) {
3488 klass->initialize(CHECK_NULL);
3489 }
3490 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3491 }
3492
3493
3494 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3495
3496 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3497 Handle method_handle;
3498 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3499 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3500 Handle receiver(THREAD, JNIHandles::resolve(obj));
3501 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3502 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3503 jobject res = JNIHandles::make_local(THREAD, result);
3504 if (JvmtiExport::should_post_vm_object_alloc()) {
3505 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3506 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3507 if (java_lang_Class::is_primitive(ret_type)) {
3508 // Only for primitive type vm allocates memory for java object.
3509 // See box() method.
3510 JvmtiExport::post_vm_object_alloc(thread, result);
3511 }
3512 }
3513 return res;
3514 } else {
3515 THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3516 }
3517 JVM_END
3518
3519
3520 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3521 objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3522 oop constructor_mirror = JNIHandles::resolve(c);
3523 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3524 jobject res = JNIHandles::make_local(THREAD, result);
3525 if (JvmtiExport::should_post_vm_object_alloc()) {
3526 JvmtiExport::post_vm_object_alloc(thread, result);
3527 }
3528 return res;
3529 JVM_END
3530
3531 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3532 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3533 assert(k->is_klass(), "just checking");
3534 HeapShared::initialize_from_archived_subgraph(THREAD, k);
3535 JVM_END
3536
3537 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3538 jclass caller,
3539 jstring interfaceMethodName,
3540 jobject factoryType,
3541 jobject interfaceMethodType,
3542 jobject implementationMember,
|