< prev index next >

src/hotspot/share/prims/jvm.cpp

Print this page

  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,
< prev index next >