< 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"

 606 
 607   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 608   return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
 609                                   start_index, frames_array_h, THREAD);
 610 JVM_END
 611 
 612 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
 613   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
 614   objArrayHandle frames_array_h(THREAD, fa);
 615   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 616   Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
 617 
 618   StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
 619 JVM_END
 620 
 621 // java.lang.Object ///////////////////////////////////////////////
 622 
 623 
 624 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
 625   // as implemented in the classic virtual machine; return 0 if object is null
 626   return handle == nullptr ? 0 :
 627          checked_cast<jint>(ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)));




















 628 JVM_END
 629 
 630 
 631 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
 632   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 633   JavaThreadInObjectWaitState jtiows(thread, ms != 0);
 634   if (JvmtiExport::should_post_monitor_wait()) {
 635     JvmtiExport::post_monitor_wait(thread, obj(), ms);
 636 
 637     // The current thread already owns the monitor and it has not yet
 638     // been added to the wait queue so the current thread cannot be
 639     // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
 640     // event handler cannot accidentally consume an unpark() meant for
 641     // the ParkEvent associated with this ObjectMonitor.
 642   }
 643   ObjectSynchronizer::wait(obj, ms, CHECK);
 644 JVM_END
 645 
 646 
 647 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))

 659 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
 660   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 661   Klass* klass = obj->klass();
 662   JvmtiVMObjectAllocEventCollector oam;
 663 
 664 #ifdef ASSERT
 665   // Just checking that the cloneable flag is set correct
 666   if (obj->is_array()) {
 667     guarantee(klass->is_cloneable(), "all arrays are cloneable");
 668   } else {
 669     guarantee(obj->is_instance(), "should be instanceOop");
 670     bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
 671     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
 672   }
 673 #endif
 674 
 675   // Check if class of obj supports the Cloneable interface.
 676   // All arrays are considered to be cloneable (See JLS 20.1.5).
 677   // All j.l.r.Reference classes are considered non-cloneable.
 678   if (!klass->is_cloneable() ||

 679       (klass->is_instance_klass() &&
 680        InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
 681     ResourceMark rm(THREAD);
 682     THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
 683   }
 684 
 685   // Make shallow object copy
 686   const size_t size = obj->size();
 687   oop new_obj_oop = nullptr;
 688   if (obj->is_array()) {
 689     const int length = ((arrayOop)obj())->length();
 690     new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
 691                                                    /* do_zero */ true, CHECK_NULL);
 692   } else {
 693     new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
 694   }
 695 
 696   HeapAccess<>::clone(obj(), new_obj_oop, size);
 697 
 698   Handle new_obj(THREAD, new_obj_oop);

1175   oop result = java_lang_Class::name(java_class, CHECK_NULL);
1176   return (jstring) JNIHandles::make_local(THREAD, result);
1177 JVM_END
1178 
1179 
1180 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1181   JvmtiVMObjectAllocEventCollector oam;
1182   oop mirror = JNIHandles::resolve_non_null(cls);
1183 
1184   // Special handling for primitive objects
1185   if (java_lang_Class::is_primitive(mirror)) {
1186     // Primitive objects does not have any interfaces
1187     objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1188     return (jobjectArray) JNIHandles::make_local(THREAD, r);
1189   }
1190 
1191   Klass* klass = java_lang_Class::as_Klass(mirror);
1192   // Figure size of result array
1193   int size;
1194   if (klass->is_instance_klass()) {
1195     size = InstanceKlass::cast(klass)->local_interfaces()->length();

1196   } else {
1197     assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1198     size = 2;
1199   }
1200 
1201   // Allocate result array
1202   objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1203   objArrayHandle result (THREAD, r);
1204   // Fill in result
1205   if (klass->is_instance_klass()) {
1206     // Regular instance klass, fill in all local interfaces
1207     for (int index = 0; index < size; index++) {
1208       Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);

1209       result->obj_at_put(index, k->java_mirror());
1210     }
1211   } else {
1212     // All arrays implement java.lang.Cloneable and java.io.Serializable
1213     result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1214     result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1215   }
1216   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1217 JVM_END
1218 
1219 
1220 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1221   oop mirror = JNIHandles::resolve_non_null(cls);
1222   if (java_lang_Class::is_primitive(mirror)) {
1223     return JNI_FALSE;
1224   }
1225   Klass* k = java_lang_Class::as_Klass(mirror);
1226   jboolean result = k->is_interface();
1227   assert(!result || k->is_instance_klass(),
1228          "all interfaces are instance types");
1229   // The compiler intrinsic for isInterface tests the
1230   // Klass::_access_flags bits in the same way.
1231   return result;
1232 JVM_END
1233 
1234 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1235   oop mirror = JNIHandles::resolve_non_null(cls);
1236   if (java_lang_Class::is_primitive(mirror)) {
1237     return JNI_FALSE;
1238   }
1239   Klass* k = java_lang_Class::as_Klass(mirror);
1240   return k->is_hidden();
1241 JVM_END
1242 













1243 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1244   JvmtiVMObjectAllocEventCollector oam;
1245   oop mirror = JNIHandles::resolve_non_null(cls);
1246   if (java_lang_Class::is_primitive(mirror)) {
1247     // There are no signers for primitive types
1248     return nullptr;
1249   }
1250 
1251   objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1252 
1253   // If there are no signers set in the class, or if the class
1254   // is an array, return null.
1255   if (signers == nullptr) return nullptr;
1256 
1257   // copy of the signers array
1258   Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1259   objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1260   for (int index = 0; index < signers->length(); index++) {
1261     signers_copy->obj_at_put(index, signers->obj_at(index));
1262   }

1837     int length = components->length();
1838     assert(length >= 0, "unexpected record_components length");
1839     objArrayOop record_components =
1840       oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1841     objArrayHandle components_h (THREAD, record_components);
1842 
1843     for (int x = 0; x < length; x++) {
1844       RecordComponent* component = components->at(x);
1845       assert(component != nullptr, "unexpected null record component");
1846       oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1847       components_h->obj_at_put(x, component_oop);
1848     }
1849     return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1850   }
1851 
1852   return nullptr;
1853 }
1854 JVM_END
1855 
1856 static bool select_method(const methodHandle& method, bool want_constructor) {


1857   if (want_constructor) {
1858     return (method->is_initializer() && !method->is_static());
1859   } else {
1860     return  (!method->is_initializer() && !method->is_overpass());


1861   }
1862 }
1863 
1864 static jobjectArray get_class_declared_methods_helper(
1865                                   JNIEnv *env,
1866                                   jclass ofClass, jboolean publicOnly,
1867                                   bool want_constructor,
1868                                   Klass* klass, TRAPS) {
1869 
1870   JvmtiVMObjectAllocEventCollector oam;
1871 
1872   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1873   // Exclude primitive types and array types
1874   if (java_lang_Class::is_primitive(ofMirror)
1875       || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1876     // Return empty array
1877     oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1878     return (jobjectArray) JNIHandles::make_local(THREAD, res);
1879   }
1880 

1903     }
1904   }
1905 
1906   // Allocate result
1907   objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1908   objArrayHandle result (THREAD, r);
1909 
1910   // Now just put the methods that we selected above, but go by their idnum
1911   // in case of redefinition.  The methods can be redefined at any safepoint,
1912   // so above when allocating the oop array and below when creating reflect
1913   // objects.
1914   for (int i = 0; i < num_methods; i++) {
1915     methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1916     if (method.is_null()) {
1917       // Method may have been deleted and seems this API can handle null
1918       // Otherwise should probably put a method that throws NSME
1919       result->obj_at_put(i, nullptr);
1920     } else {
1921       oop m;
1922       if (want_constructor) {


1923         m = Reflection::new_constructor(method, CHECK_NULL);
1924       } else {
1925         m = Reflection::new_method(method, false, CHECK_NULL);
1926       }
1927       result->obj_at_put(i, m);
1928     }
1929   }
1930 
1931   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1932 }
1933 
1934 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1935 {
1936   return get_class_declared_methods_helper(env, ofClass, publicOnly,
1937                                            /*want_constructor*/ false,
1938                                            vmClasses::reflect_Method_klass(), THREAD);
1939 }
1940 JVM_END
1941 
1942 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))

2185   constantTag tag = cp->tag_at(index);
2186   if (!tag.is_method() && !tag.is_interface_method()) {
2187     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2188   }
2189   int klass_ref  = cp->uncached_klass_ref_index_at(index);
2190   Klass* k_o;
2191   if (force_resolution) {
2192     k_o = cp->klass_at(klass_ref, CHECK_NULL);
2193   } else {
2194     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2195     if (k_o == nullptr) return nullptr;
2196   }
2197   InstanceKlass* k = InstanceKlass::cast(k_o);
2198   Symbol* name = cp->uncached_name_ref_at(index);
2199   Symbol* sig  = cp->uncached_signature_ref_at(index);
2200   methodHandle m (THREAD, k->find_method(name, sig));
2201   if (m.is_null()) {
2202     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2203   }
2204   oop method;
2205   if (!m->is_initializer() || m->is_static()) {
2206     method = Reflection::new_method(m, true, CHECK_NULL);
2207   } else {
2208     method = Reflection::new_constructor(m, CHECK_NULL);


2209   }
2210   return JNIHandles::make_local(THREAD, method);
2211 }
2212 
2213 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2214 {
2215   JvmtiVMObjectAllocEventCollector oam;
2216   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2217   bounds_check(cp, index, CHECK_NULL);
2218   jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2219   return res;
2220 }
2221 JVM_END
2222 
2223 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2224 {
2225   JvmtiVMObjectAllocEventCollector oam;
2226   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2227   bounds_check(cp, index, CHECK_NULL);
2228   jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);

2459   Klass* k = java_lang_Class::as_Klass(r);
2460   assert(k->is_instance_klass(), "must be an instance klass");
2461   if (!k->is_instance_klass()) return false;
2462 
2463   ResourceMark rm(THREAD);
2464   const char* name = k->name()->as_C_string();
2465   bool system_class = k->class_loader() == nullptr;
2466   return JavaAssertions::enabled(name, system_class);
2467 
2468 JVM_END
2469 
2470 
2471 // Return a new AssertionStatusDirectives object with the fields filled in with
2472 // command-line assertion arguments (i.e., -ea, -da).
2473 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2474   JvmtiVMObjectAllocEventCollector oam;
2475   oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2476   return JNIHandles::make_local(THREAD, asd);
2477 JVM_END
2478 





































2479 // Verification ////////////////////////////////////////////////////////////////////////////////
2480 
2481 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2482 
2483 // RedefineClasses support: bug 6214132 caused verification to fail.
2484 // All functions from this section should call the jvmtiThreadSate function:
2485 //   Klass* class_to_verify_considering_redefinition(Klass* klass).
2486 // The function returns a Klass* of the _scratch_class if the verifier
2487 // was invoked in the middle of the class redefinition.
2488 // Otherwise it returns its argument value which is the _the_class Klass*.
2489 // Please, refer to the description in the jvmtiThreadSate.hpp.
2490 
2491 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2492   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2493   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2494   return k->name()->as_utf8();
2495 JVM_END
2496 
2497 
2498 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))

2621   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2622   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2623   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2624   return method->size_of_parameters();
2625 JVM_END
2626 
2627 
2628 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2629   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2630   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2631   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2632   return method->verifier_max_stack();
2633 JVM_END
2634 
2635 
2636 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2637   ResourceMark rm(THREAD);
2638   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2639   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2640   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2641   return method->name() == vmSymbols::object_initializer_name();
2642 JVM_END
2643 
2644 
2645 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2646   ResourceMark rm(THREAD);
2647   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2648   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2649   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2650   return method->is_overpass();
2651 JVM_END
2652 
2653 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2654   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2655   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2656   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2657   return method->name()->as_utf8();
2658 JVM_END
2659 
2660 
2661 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))

3459 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3460   void* find_result = os::dll_lookup(handle, name);
3461   log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3462                     find_result != nullptr ? "Found" : "Failed to find",
3463                     name, p2i(handle));
3464   return find_result;
3465 JVM_END
3466 
3467 
3468 // JNI version ///////////////////////////////////////////////////////////////////////////////
3469 
3470 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3471   return Threads::is_supported_jni_version_including_1_1(version);
3472 JVM_END
3473 
3474 
3475 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3476   return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3477 JVM_END
3478 




3479 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3480   return VMContinuations ? JNI_TRUE : JNI_FALSE;
3481 JVM_END
3482 
3483 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3484   return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3485 JVM_END
3486 
3487 // String support ///////////////////////////////////////////////////////////////////////////
3488 
3489 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3490   JvmtiVMObjectAllocEventCollector oam;
3491   if (str == nullptr) return nullptr;
3492   oop string = JNIHandles::resolve_non_null(str);
3493   oop result = StringTable::intern(string, CHECK_NULL);
3494   return (jstring) JNIHandles::make_local(THREAD, result);
3495 JVM_END
3496 
3497 
3498 // VM Raw monitor support //////////////////////////////////////////////////////////////////////

3540   //   the checkPackageAccess relative to the initiating class loader via the
3541   //   protection_domain. The protection_domain is passed as null by the java code
3542   //   if there is no security manager in 3-arg Class.forName().
3543   Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3544 
3545   // Check if we should initialize the class
3546   if (init && klass->is_instance_klass()) {
3547     klass->initialize(CHECK_NULL);
3548   }
3549   return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3550 }
3551 
3552 
3553 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3554 
3555 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3556   Handle method_handle;
3557   if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3558     method_handle = Handle(THREAD, JNIHandles::resolve(method));
3559     Handle receiver(THREAD, JNIHandles::resolve(obj));
3560     objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3561     oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3562     jobject res = JNIHandles::make_local(THREAD, result);
3563     if (JvmtiExport::should_post_vm_object_alloc()) {
3564       oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3565       assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3566       if (java_lang_Class::is_primitive(ret_type)) {
3567         // Only for primitive type vm allocates memory for java object.
3568         // See box() method.
3569         JvmtiExport::post_vm_object_alloc(thread, result);
3570       }
3571     }
3572     return res;
3573   } else {
3574     THROW_0(vmSymbols::java_lang_StackOverflowError());
3575   }
3576 JVM_END
3577 
3578 
3579 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))

3580   oop constructor_mirror = JNIHandles::resolve(c);
3581   objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3582   oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3583   jobject res = JNIHandles::make_local(THREAD, result);
3584   if (JvmtiExport::should_post_vm_object_alloc()) {
3585     JvmtiExport::post_vm_object_alloc(thread, result);
3586   }
3587   return res;
3588 JVM_END
3589 
3590 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3591 
3592 JVM_LEAF(jboolean, JVM_SupportsCX8())
3593   return VM_Version::supports_cx8();
3594 JVM_END
3595 
3596 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3597   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3598   assert(k->is_klass(), "just checking");
3599   HeapShared::initialize_from_archived_subgraph(THREAD, k);
3600 JVM_END
3601 

  39 #include "classfile/modules.hpp"
  40 #include "classfile/packageEntry.hpp"
  41 #include "classfile/stringTable.hpp"
  42 #include "classfile/symbolTable.hpp"
  43 #include "classfile/systemDictionary.hpp"
  44 #include "classfile/vmClasses.hpp"
  45 #include "classfile/vmSymbols.hpp"
  46 #include "gc/shared/collectedHeap.inline.hpp"
  47 #include "interpreter/bytecode.hpp"
  48 #include "interpreter/bytecodeUtils.hpp"
  49 #include "jfr/jfrEvents.hpp"
  50 #include "jvm.h"
  51 #include "logging/log.hpp"
  52 #include "memory/oopFactory.hpp"
  53 #include "memory/referenceType.hpp"
  54 #include "memory/resourceArea.hpp"
  55 #include "memory/universe.hpp"
  56 #include "oops/access.inline.hpp"
  57 #include "oops/constantPool.hpp"
  58 #include "oops/fieldStreams.inline.hpp"
  59 #include "oops/flatArrayKlass.hpp"
  60 #include "oops/instanceKlass.hpp"
  61 #include "oops/klass.inline.hpp"
  62 #include "oops/method.hpp"
  63 #include "oops/recordComponent.hpp"
  64 #include "oops/objArrayKlass.hpp"
  65 #include "oops/objArrayOop.inline.hpp"
  66 #include "oops/oop.inline.hpp"
  67 #include "prims/foreignGlobals.hpp"
  68 #include "prims/jvm_misc.hpp"
  69 #include "prims/jvmtiExport.hpp"
  70 #include "prims/jvmtiThreadState.inline.hpp"
  71 #include "prims/stackwalk.hpp"
  72 #include "runtime/arguments.hpp"
  73 #include "runtime/atomic.hpp"
  74 #include "runtime/continuation.hpp"
  75 #include "runtime/globals_extension.hpp"
  76 #include "runtime/handles.inline.hpp"
  77 #include "runtime/init.hpp"
  78 #include "runtime/interfaceSupport.inline.hpp"
  79 #include "runtime/deoptimization.hpp"

 607 
 608   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 609   return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
 610                                   start_index, frames_array_h, THREAD);
 611 JVM_END
 612 
 613 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
 614   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
 615   objArrayHandle frames_array_h(THREAD, fa);
 616   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 617   Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
 618 
 619   StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
 620 JVM_END
 621 
 622 // java.lang.Object ///////////////////////////////////////////////
 623 
 624 
 625 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
 626   // as implemented in the classic virtual machine; return 0 if object is null
 627   if (handle == nullptr) {
 628     return 0;
 629   }
 630   oop obj = JNIHandles::resolve_non_null(handle);
 631   if (EnableValhalla && obj->klass()->is_inline_klass()) {
 632       JavaValue result(T_INT);
 633       JavaCallArguments args;
 634       Handle ho(THREAD, obj);
 635       args.push_oop(ho);
 636       methodHandle method(THREAD, Universe::value_object_hash_code_method());
 637       JavaCalls::call(&result, method, &args, THREAD);
 638       if (HAS_PENDING_EXCEPTION) {
 639         if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
 640           Handle e(THREAD, PENDING_EXCEPTION);
 641           CLEAR_PENDING_EXCEPTION;
 642           THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
 643         }
 644       }
 645       return result.get_jint();
 646   } else {
 647     return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj));
 648   }
 649 JVM_END
 650 
 651 
 652 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
 653   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 654   JavaThreadInObjectWaitState jtiows(thread, ms != 0);
 655   if (JvmtiExport::should_post_monitor_wait()) {
 656     JvmtiExport::post_monitor_wait(thread, obj(), ms);
 657 
 658     // The current thread already owns the monitor and it has not yet
 659     // been added to the wait queue so the current thread cannot be
 660     // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
 661     // event handler cannot accidentally consume an unpark() meant for
 662     // the ParkEvent associated with this ObjectMonitor.
 663   }
 664   ObjectSynchronizer::wait(obj, ms, CHECK);
 665 JVM_END
 666 
 667 
 668 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))

 680 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
 681   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 682   Klass* klass = obj->klass();
 683   JvmtiVMObjectAllocEventCollector oam;
 684 
 685 #ifdef ASSERT
 686   // Just checking that the cloneable flag is set correct
 687   if (obj->is_array()) {
 688     guarantee(klass->is_cloneable(), "all arrays are cloneable");
 689   } else {
 690     guarantee(obj->is_instance(), "should be instanceOop");
 691     bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
 692     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
 693   }
 694 #endif
 695 
 696   // Check if class of obj supports the Cloneable interface.
 697   // All arrays are considered to be cloneable (See JLS 20.1.5).
 698   // All j.l.r.Reference classes are considered non-cloneable.
 699   if (!klass->is_cloneable() ||
 700        klass->is_inline_klass() ||
 701       (klass->is_instance_klass() &&
 702        InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
 703     ResourceMark rm(THREAD);
 704     THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
 705   }
 706 
 707   // Make shallow object copy
 708   const size_t size = obj->size();
 709   oop new_obj_oop = nullptr;
 710   if (obj->is_array()) {
 711     const int length = ((arrayOop)obj())->length();
 712     new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
 713                                                    /* do_zero */ true, CHECK_NULL);
 714   } else {
 715     new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
 716   }
 717 
 718   HeapAccess<>::clone(obj(), new_obj_oop, size);
 719 
 720   Handle new_obj(THREAD, new_obj_oop);

1197   oop result = java_lang_Class::name(java_class, CHECK_NULL);
1198   return (jstring) JNIHandles::make_local(THREAD, result);
1199 JVM_END
1200 
1201 
1202 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1203   JvmtiVMObjectAllocEventCollector oam;
1204   oop mirror = JNIHandles::resolve_non_null(cls);
1205 
1206   // Special handling for primitive objects
1207   if (java_lang_Class::is_primitive(mirror)) {
1208     // Primitive objects does not have any interfaces
1209     objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1210     return (jobjectArray) JNIHandles::make_local(THREAD, r);
1211   }
1212 
1213   Klass* klass = java_lang_Class::as_Klass(mirror);
1214   // Figure size of result array
1215   int size;
1216   if (klass->is_instance_klass()) {
1217     InstanceKlass* ik = InstanceKlass::cast(klass);
1218     size = ik->local_interfaces()->length();
1219   } else {
1220     assert(klass->is_objArray_klass() || klass->is_typeArray_klass() || klass->is_flatArray_klass(), "Illegal mirror klass");
1221     size = 2;
1222   }
1223 
1224   // Allocate result array
1225   objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1226   objArrayHandle result (THREAD, r);
1227   // Fill in result
1228   if (klass->is_instance_klass()) {
1229     // Regular instance klass, fill in all local interfaces
1230     for (int index = 0; index < size; index++) {
1231       InstanceKlass* ik = InstanceKlass::cast(klass);
1232       Klass* k = ik->local_interfaces()->at(index);
1233       result->obj_at_put(index, k->java_mirror());
1234     }
1235   } else {
1236     // All arrays implement java.lang.Cloneable and java.io.Serializable
1237     result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1238     result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1239   }
1240   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1241 JVM_END
1242 
1243 
1244 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1245   oop mirror = JNIHandles::resolve_non_null(cls);
1246   if (java_lang_Class::is_primitive(mirror)) {
1247     return JNI_FALSE;
1248   }
1249   Klass* k = java_lang_Class::as_Klass(mirror);
1250   jboolean result = k->is_interface();
1251   assert(!result || k->is_instance_klass(),
1252          "all interfaces are instance types");
1253   // The compiler intrinsic for isInterface tests the
1254   // Klass::_access_flags bits in the same way.
1255   return result;
1256 JVM_END
1257 
1258 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1259   oop mirror = JNIHandles::resolve_non_null(cls);
1260   if (java_lang_Class::is_primitive(mirror)) {
1261     return JNI_FALSE;
1262   }
1263   Klass* k = java_lang_Class::as_Klass(mirror);
1264   return k->is_hidden();
1265 JVM_END
1266 
1267 JVM_ENTRY(jboolean, JVM_IsIdentityClass(JNIEnv *env, jclass cls))
1268   oop mirror = JNIHandles::resolve_non_null(cls);
1269   if (java_lang_Class::is_primitive(mirror)) {
1270     return JNI_FALSE;
1271   }
1272   Klass* k = java_lang_Class::as_Klass(mirror);
1273   if (EnableValhalla) {
1274     return k->is_array_klass() || k->is_identity_class();
1275   } else {
1276     return k->is_interface() ? JNI_FALSE : JNI_TRUE;
1277   }
1278 JVM_END
1279 
1280 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1281   JvmtiVMObjectAllocEventCollector oam;
1282   oop mirror = JNIHandles::resolve_non_null(cls);
1283   if (java_lang_Class::is_primitive(mirror)) {
1284     // There are no signers for primitive types
1285     return nullptr;
1286   }
1287 
1288   objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1289 
1290   // If there are no signers set in the class, or if the class
1291   // is an array, return null.
1292   if (signers == nullptr) return nullptr;
1293 
1294   // copy of the signers array
1295   Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1296   objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1297   for (int index = 0; index < signers->length(); index++) {
1298     signers_copy->obj_at_put(index, signers->obj_at(index));
1299   }

1874     int length = components->length();
1875     assert(length >= 0, "unexpected record_components length");
1876     objArrayOop record_components =
1877       oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1878     objArrayHandle components_h (THREAD, record_components);
1879 
1880     for (int x = 0; x < length; x++) {
1881       RecordComponent* component = components->at(x);
1882       assert(component != nullptr, "unexpected null record component");
1883       oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1884       components_h->obj_at_put(x, component_oop);
1885     }
1886     return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1887   }
1888 
1889   return nullptr;
1890 }
1891 JVM_END
1892 
1893 static bool select_method(const methodHandle& method, bool want_constructor) {
1894   bool is_ctor = (method->is_object_constructor() ||
1895                   method->is_static_vnew_factory());
1896   if (want_constructor) {
1897     return is_ctor;
1898   } else {
1899     return (!is_ctor &&
1900             !method->is_class_initializer() &&
1901             !method->is_overpass());
1902   }
1903 }
1904 
1905 static jobjectArray get_class_declared_methods_helper(
1906                                   JNIEnv *env,
1907                                   jclass ofClass, jboolean publicOnly,
1908                                   bool want_constructor,
1909                                   Klass* klass, TRAPS) {
1910 
1911   JvmtiVMObjectAllocEventCollector oam;
1912 
1913   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1914   // Exclude primitive types and array types
1915   if (java_lang_Class::is_primitive(ofMirror)
1916       || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1917     // Return empty array
1918     oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1919     return (jobjectArray) JNIHandles::make_local(THREAD, res);
1920   }
1921 

1944     }
1945   }
1946 
1947   // Allocate result
1948   objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1949   objArrayHandle result (THREAD, r);
1950 
1951   // Now just put the methods that we selected above, but go by their idnum
1952   // in case of redefinition.  The methods can be redefined at any safepoint,
1953   // so above when allocating the oop array and below when creating reflect
1954   // objects.
1955   for (int i = 0; i < num_methods; i++) {
1956     methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1957     if (method.is_null()) {
1958       // Method may have been deleted and seems this API can handle null
1959       // Otherwise should probably put a method that throws NSME
1960       result->obj_at_put(i, nullptr);
1961     } else {
1962       oop m;
1963       if (want_constructor) {
1964         assert(method->is_object_constructor() ||
1965                method->is_static_vnew_factory(), "must be");
1966         m = Reflection::new_constructor(method, CHECK_NULL);
1967       } else {
1968         m = Reflection::new_method(method, false, CHECK_NULL);
1969       }
1970       result->obj_at_put(i, m);
1971     }
1972   }
1973 
1974   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1975 }
1976 
1977 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1978 {
1979   return get_class_declared_methods_helper(env, ofClass, publicOnly,
1980                                            /*want_constructor*/ false,
1981                                            vmClasses::reflect_Method_klass(), THREAD);
1982 }
1983 JVM_END
1984 
1985 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))

2228   constantTag tag = cp->tag_at(index);
2229   if (!tag.is_method() && !tag.is_interface_method()) {
2230     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2231   }
2232   int klass_ref  = cp->uncached_klass_ref_index_at(index);
2233   Klass* k_o;
2234   if (force_resolution) {
2235     k_o = cp->klass_at(klass_ref, CHECK_NULL);
2236   } else {
2237     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2238     if (k_o == nullptr) return nullptr;
2239   }
2240   InstanceKlass* k = InstanceKlass::cast(k_o);
2241   Symbol* name = cp->uncached_name_ref_at(index);
2242   Symbol* sig  = cp->uncached_signature_ref_at(index);
2243   methodHandle m (THREAD, k->find_method(name, sig));
2244   if (m.is_null()) {
2245     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2246   }
2247   oop method;
2248   if (m->is_object_constructor() || m->is_static_vnew_factory()) {


2249     method = Reflection::new_constructor(m, CHECK_NULL);
2250   } else {
2251     method = Reflection::new_method(m, true, CHECK_NULL);
2252   }
2253   return JNIHandles::make_local(THREAD, method);
2254 }
2255 
2256 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2257 {
2258   JvmtiVMObjectAllocEventCollector oam;
2259   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2260   bounds_check(cp, index, CHECK_NULL);
2261   jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2262   return res;
2263 }
2264 JVM_END
2265 
2266 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2267 {
2268   JvmtiVMObjectAllocEventCollector oam;
2269   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2270   bounds_check(cp, index, CHECK_NULL);
2271   jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);

2502   Klass* k = java_lang_Class::as_Klass(r);
2503   assert(k->is_instance_klass(), "must be an instance klass");
2504   if (!k->is_instance_klass()) return false;
2505 
2506   ResourceMark rm(THREAD);
2507   const char* name = k->name()->as_C_string();
2508   bool system_class = k->class_loader() == nullptr;
2509   return JavaAssertions::enabled(name, system_class);
2510 
2511 JVM_END
2512 
2513 
2514 // Return a new AssertionStatusDirectives object with the fields filled in with
2515 // command-line assertion arguments (i.e., -ea, -da).
2516 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2517   JvmtiVMObjectAllocEventCollector oam;
2518   oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2519   return JNIHandles::make_local(THREAD, asd);
2520 JVM_END
2521 
2522 // Arrays support /////////////////////////////////////////////////////////////
2523 
2524 JVM_ENTRY(jboolean, JVM_ArrayIsAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2525   oop o = JNIHandles::resolve(array);
2526   Klass* k = o->klass();
2527   if ((o == nullptr) || (!k->is_array_klass())) {
2528     THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2529   }
2530   return ArrayKlass::cast(k)->element_access_is_atomic();
2531 JVM_END
2532 
2533 JVM_ENTRY(jobject, JVM_ArrayEnsureAccessAtomic(JNIEnv *env, jclass unused, jobject array))
2534   oop o = JNIHandles::resolve(array);
2535   Klass* k = o->klass();
2536   if ((o == nullptr) || (!k->is_array_klass())) {
2537     THROW_0(vmSymbols::java_lang_IllegalArgumentException());
2538   }
2539   if (k->is_flatArray_klass()) {
2540     FlatArrayKlass* vk = FlatArrayKlass::cast(k);
2541     if (!vk->element_access_is_atomic()) {
2542       /**
2543        * Need to decide how to implement:
2544        *
2545        * 1) Change to objArrayOop layout, therefore oop->klass() differs so
2546        * then "<atomic>[Qfoo;" klass needs to subclass "[Qfoo;" to pass through
2547        * "checkcast" & "instanceof"
2548        *
2549        * 2) Use extra header in the flatArrayOop to flag atomicity required and
2550        * possibly per instance lock structure. Said info, could be placed in
2551        * "trailer" rather than disturb the current arrayOop
2552        */
2553       Unimplemented();
2554     }
2555   }
2556   return array;
2557 JVM_END
2558 
2559 // Verification ////////////////////////////////////////////////////////////////////////////////
2560 
2561 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2562 
2563 // RedefineClasses support: bug 6214132 caused verification to fail.
2564 // All functions from this section should call the jvmtiThreadSate function:
2565 //   Klass* class_to_verify_considering_redefinition(Klass* klass).
2566 // The function returns a Klass* of the _scratch_class if the verifier
2567 // was invoked in the middle of the class redefinition.
2568 // Otherwise it returns its argument value which is the _the_class Klass*.
2569 // Please, refer to the description in the jvmtiThreadSate.hpp.
2570 
2571 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2572   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2573   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2574   return k->name()->as_utf8();
2575 JVM_END
2576 
2577 
2578 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))

2701   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2702   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2703   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2704   return method->size_of_parameters();
2705 JVM_END
2706 
2707 
2708 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2709   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2710   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2711   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2712   return method->verifier_max_stack();
2713 JVM_END
2714 
2715 
2716 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2717   ResourceMark rm(THREAD);
2718   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2719   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2720   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2721   return method->is_object_constructor();
2722 JVM_END
2723 
2724 
2725 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2726   ResourceMark rm(THREAD);
2727   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2728   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2729   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2730   return method->is_overpass();
2731 JVM_END
2732 
2733 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2734   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2735   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2736   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2737   return method->name()->as_utf8();
2738 JVM_END
2739 
2740 
2741 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))

3539 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3540   void* find_result = os::dll_lookup(handle, name);
3541   log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3542                     find_result != nullptr ? "Found" : "Failed to find",
3543                     name, p2i(handle));
3544   return find_result;
3545 JVM_END
3546 
3547 
3548 // JNI version ///////////////////////////////////////////////////////////////////////////////
3549 
3550 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3551   return Threads::is_supported_jni_version_including_1_1(version);
3552 JVM_END
3553 
3554 
3555 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3556   return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3557 JVM_END
3558 
3559 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3560   return EnableValhalla ? JNI_TRUE : JNI_FALSE;
3561 JVM_END
3562 
3563 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3564   return VMContinuations ? JNI_TRUE : JNI_FALSE;
3565 JVM_END
3566 
3567 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3568   return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3569 JVM_END
3570 
3571 // String support ///////////////////////////////////////////////////////////////////////////
3572 
3573 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3574   JvmtiVMObjectAllocEventCollector oam;
3575   if (str == nullptr) return nullptr;
3576   oop string = JNIHandles::resolve_non_null(str);
3577   oop result = StringTable::intern(string, CHECK_NULL);
3578   return (jstring) JNIHandles::make_local(THREAD, result);
3579 JVM_END
3580 
3581 
3582 // VM Raw monitor support //////////////////////////////////////////////////////////////////////

3624   //   the checkPackageAccess relative to the initiating class loader via the
3625   //   protection_domain. The protection_domain is passed as null by the java code
3626   //   if there is no security manager in 3-arg Class.forName().
3627   Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3628 
3629   // Check if we should initialize the class
3630   if (init && klass->is_instance_klass()) {
3631     klass->initialize(CHECK_NULL);
3632   }
3633   return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3634 }
3635 
3636 
3637 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3638 
3639 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3640   Handle method_handle;
3641   if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3642     method_handle = Handle(THREAD, JNIHandles::resolve(method));
3643     Handle receiver(THREAD, JNIHandles::resolve(obj));
3644     objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3645     oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3646     jobject res = JNIHandles::make_local(THREAD, result);
3647     if (JvmtiExport::should_post_vm_object_alloc()) {
3648       oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3649       assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3650       if (java_lang_Class::is_primitive(ret_type)) {
3651         // Only for primitive type vm allocates memory for java object.
3652         // See box() method.
3653         JvmtiExport::post_vm_object_alloc(thread, result);
3654       }
3655     }
3656     return res;
3657   } else {
3658     THROW_0(vmSymbols::java_lang_StackOverflowError());
3659   }
3660 JVM_END
3661 
3662 
3663 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3664   objArrayHandle args = oopFactory::ensure_objArray(JNIHandles::resolve(args0), CHECK_NULL);
3665   oop constructor_mirror = JNIHandles::resolve(c);

3666   oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3667   jobject res = JNIHandles::make_local(THREAD, result);
3668   if (JvmtiExport::should_post_vm_object_alloc()) {
3669     JvmtiExport::post_vm_object_alloc(thread, result);
3670   }
3671   return res;
3672 JVM_END
3673 
3674 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3675 
3676 JVM_LEAF(jboolean, JVM_SupportsCX8())
3677   return VM_Version::supports_cx8();
3678 JVM_END
3679 
3680 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3681   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3682   assert(k->is_klass(), "just checking");
3683   HeapShared::initialize_from_archived_subgraph(THREAD, k);
3684 JVM_END
3685 
< prev index next >