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

 590   }
 591 
 592   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 593   return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
 594                                   start_index, frames_array_h, THREAD);
 595 JVM_END
 596 
 597 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
 598   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
 599   objArrayHandle frames_array_h(THREAD, fa);
 600   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 601   Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
 602 
 603   StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
 604 JVM_END
 605 
 606 // java.lang.Object ///////////////////////////////////////////////
 607 
 608 
 609 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
 610   // as implemented in the classic virtual machine; return 0 if object is null
 611   return handle == nullptr ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;





















 612 JVM_END
 613 
 614 
 615 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
 616   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 617   JavaThreadInObjectWaitState jtiows(thread, ms != 0);
 618   if (JvmtiExport::should_post_monitor_wait()) {
 619     JvmtiExport::post_monitor_wait(thread, obj(), ms);
 620 
 621     // The current thread already owns the monitor and it has not yet
 622     // been added to the wait queue so the current thread cannot be
 623     // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
 624     // event handler cannot accidentally consume an unpark() meant for
 625     // the ParkEvent associated with this ObjectMonitor.
 626   }
 627   ObjectSynchronizer::wait(obj, ms, CHECK);
 628 JVM_END
 629 
 630 
 631 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))

 643 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
 644   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 645   Klass* klass = obj->klass();
 646   JvmtiVMObjectAllocEventCollector oam;
 647 
 648 #ifdef ASSERT
 649   // Just checking that the cloneable flag is set correct
 650   if (obj->is_array()) {
 651     guarantee(klass->is_cloneable(), "all arrays are cloneable");
 652   } else {
 653     guarantee(obj->is_instance(), "should be instanceOop");
 654     bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
 655     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
 656   }
 657 #endif
 658 
 659   // Check if class of obj supports the Cloneable interface.
 660   // All arrays are considered to be cloneable (See JLS 20.1.5).
 661   // All j.l.r.Reference classes are considered non-cloneable.
 662   if (!klass->is_cloneable() ||

 663       (klass->is_instance_klass() &&
 664        InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
 665     ResourceMark rm(THREAD);
 666     THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
 667   }
 668 
 669   // Make shallow object copy
 670   const size_t size = obj->size();
 671   oop new_obj_oop = nullptr;
 672   if (obj->is_array()) {
 673     const int length = ((arrayOop)obj())->length();
 674     new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
 675                                                    /* do_zero */ true, CHECK_NULL);
 676   } else {
 677     new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
 678   }
 679 
 680   HeapAccess<>::clone(obj(), new_obj_oop, size);
 681 
 682   Handle new_obj(THREAD, new_obj_oop);

1156   oop result = java_lang_Class::name(java_class, CHECK_NULL);
1157   return (jstring) JNIHandles::make_local(THREAD, result);
1158 JVM_END
1159 
1160 
1161 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1162   JvmtiVMObjectAllocEventCollector oam;
1163   oop mirror = JNIHandles::resolve_non_null(cls);
1164 
1165   // Special handling for primitive objects
1166   if (java_lang_Class::is_primitive(mirror)) {
1167     // Primitive objects does not have any interfaces
1168     objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1169     return (jobjectArray) JNIHandles::make_local(THREAD, r);
1170   }
1171 
1172   Klass* klass = java_lang_Class::as_Klass(mirror);
1173   // Figure size of result array
1174   int size;
1175   if (klass->is_instance_klass()) {
1176     size = InstanceKlass::cast(klass)->local_interfaces()->length();

1177   } else {
1178     assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1179     size = 2;
1180   }
1181 
1182   // Allocate result array
1183   objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1184   objArrayHandle result (THREAD, r);
1185   // Fill in result
1186   if (klass->is_instance_klass()) {
1187     // Regular instance klass, fill in all local interfaces
1188     for (int index = 0; index < size; index++) {
1189       Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);

1190       result->obj_at_put(index, k->java_mirror());
1191     }
1192   } else {
1193     // All arrays implement java.lang.Cloneable and java.io.Serializable
1194     result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1195     result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1196   }
1197   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1198 JVM_END
1199 
1200 
1201 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1202   oop mirror = JNIHandles::resolve_non_null(cls);
1203   if (java_lang_Class::is_primitive(mirror)) {
1204     return JNI_FALSE;
1205   }
1206   Klass* k = java_lang_Class::as_Klass(mirror);
1207   jboolean result = k->is_interface();
1208   assert(!result || k->is_instance_klass(),
1209          "all interfaces are instance types");
1210   // The compiler intrinsic for isInterface tests the
1211   // Klass::_access_flags bits in the same way.
1212   return result;
1213 JVM_END
1214 
1215 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1216   oop mirror = JNIHandles::resolve_non_null(cls);
1217   if (java_lang_Class::is_primitive(mirror)) {
1218     return JNI_FALSE;
1219   }
1220   Klass* k = java_lang_Class::as_Klass(mirror);
1221   return k->is_hidden();
1222 JVM_END
1223 













1224 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1225   JvmtiVMObjectAllocEventCollector oam;
1226   oop mirror = JNIHandles::resolve_non_null(cls);
1227   if (java_lang_Class::is_primitive(mirror)) {
1228     // There are no signers for primitive types
1229     return nullptr;
1230   }
1231 
1232   objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1233 
1234   // If there are no signers set in the class, or if the class
1235   // is an array, return null.
1236   if (signers == nullptr) return nullptr;
1237 
1238   // copy of the signers array
1239   Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1240   objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1241   for (int index = 0; index < signers->length(); index++) {
1242     signers_copy->obj_at_put(index, signers->obj_at(index));
1243   }

1819     int length = components->length();
1820     assert(length >= 0, "unexpected record_components length");
1821     objArrayOop record_components =
1822       oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1823     objArrayHandle components_h (THREAD, record_components);
1824 
1825     for (int x = 0; x < length; x++) {
1826       RecordComponent* component = components->at(x);
1827       assert(component != nullptr, "unexpected null record component");
1828       oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1829       components_h->obj_at_put(x, component_oop);
1830     }
1831     return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1832   }
1833 
1834   return nullptr;
1835 }
1836 JVM_END
1837 
1838 static bool select_method(const methodHandle& method, bool want_constructor) {


1839   if (want_constructor) {
1840     return (method->is_initializer() && !method->is_static());
1841   } else {
1842     return  (!method->is_initializer() && !method->is_overpass());


1843   }
1844 }
1845 
1846 static jobjectArray get_class_declared_methods_helper(
1847                                   JNIEnv *env,
1848                                   jclass ofClass, jboolean publicOnly,
1849                                   bool want_constructor,
1850                                   Klass* klass, TRAPS) {
1851 
1852   JvmtiVMObjectAllocEventCollector oam;
1853 
1854   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1855   // Exclude primitive types and array types
1856   if (java_lang_Class::is_primitive(ofMirror)
1857       || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1858     // Return empty array
1859     oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1860     return (jobjectArray) JNIHandles::make_local(THREAD, res);
1861   }
1862 

1885     }
1886   }
1887 
1888   // Allocate result
1889   objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1890   objArrayHandle result (THREAD, r);
1891 
1892   // Now just put the methods that we selected above, but go by their idnum
1893   // in case of redefinition.  The methods can be redefined at any safepoint,
1894   // so above when allocating the oop array and below when creating reflect
1895   // objects.
1896   for (int i = 0; i < num_methods; i++) {
1897     methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1898     if (method.is_null()) {
1899       // Method may have been deleted and seems this API can handle null
1900       // Otherwise should probably put a method that throws NSME
1901       result->obj_at_put(i, nullptr);
1902     } else {
1903       oop m;
1904       if (want_constructor) {


1905         m = Reflection::new_constructor(method, CHECK_NULL);
1906       } else {
1907         m = Reflection::new_method(method, false, CHECK_NULL);
1908       }
1909       result->obj_at_put(i, m);
1910     }
1911   }
1912 
1913   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1914 }
1915 
1916 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1917 {
1918   return get_class_declared_methods_helper(env, ofClass, publicOnly,
1919                                            /*want_constructor*/ false,
1920                                            vmClasses::reflect_Method_klass(), THREAD);
1921 }
1922 JVM_END
1923 
1924 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))

2167   constantTag tag = cp->tag_at(index);
2168   if (!tag.is_method() && !tag.is_interface_method()) {
2169     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2170   }
2171   int klass_ref  = cp->uncached_klass_ref_index_at(index);
2172   Klass* k_o;
2173   if (force_resolution) {
2174     k_o = cp->klass_at(klass_ref, CHECK_NULL);
2175   } else {
2176     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2177     if (k_o == nullptr) return nullptr;
2178   }
2179   InstanceKlass* k = InstanceKlass::cast(k_o);
2180   Symbol* name = cp->uncached_name_ref_at(index);
2181   Symbol* sig  = cp->uncached_signature_ref_at(index);
2182   methodHandle m (THREAD, k->find_method(name, sig));
2183   if (m.is_null()) {
2184     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2185   }
2186   oop method;
2187   if (!m->is_initializer() || m->is_static()) {
2188     method = Reflection::new_method(m, true, CHECK_NULL);
2189   } else {
2190     method = Reflection::new_constructor(m, CHECK_NULL);


2191   }
2192   return JNIHandles::make_local(THREAD, method);
2193 }
2194 
2195 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2196 {
2197   JvmtiVMObjectAllocEventCollector oam;
2198   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2199   bounds_check(cp, index, CHECK_NULL);
2200   jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2201   return res;
2202 }
2203 JVM_END
2204 
2205 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2206 {
2207   JvmtiVMObjectAllocEventCollector oam;
2208   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2209   bounds_check(cp, index, CHECK_NULL);
2210   jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);

2441   Klass* k = java_lang_Class::as_Klass(r);
2442   assert(k->is_instance_klass(), "must be an instance klass");
2443   if (!k->is_instance_klass()) return false;
2444 
2445   ResourceMark rm(THREAD);
2446   const char* name = k->name()->as_C_string();
2447   bool system_class = k->class_loader() == nullptr;
2448   return JavaAssertions::enabled(name, system_class);
2449 
2450 JVM_END
2451 
2452 
2453 // Return a new AssertionStatusDirectives object with the fields filled in with
2454 // command-line assertion arguments (i.e., -ea, -da).
2455 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2456   JvmtiVMObjectAllocEventCollector oam;
2457   oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2458   return JNIHandles::make_local(THREAD, asd);
2459 JVM_END
2460 





































2461 // Verification ////////////////////////////////////////////////////////////////////////////////
2462 
2463 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2464 
2465 // RedefineClasses support: bug 6214132 caused verification to fail.
2466 // All functions from this section should call the jvmtiThreadSate function:
2467 //   Klass* class_to_verify_considering_redefinition(Klass* klass).
2468 // The function returns a Klass* of the _scratch_class if the verifier
2469 // was invoked in the middle of the class redefinition.
2470 // Otherwise it returns its argument value which is the _the_class Klass*.
2471 // Please, refer to the description in the jvmtiThreadSate.hpp.
2472 
2473 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2474   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2475   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2476   return k->name()->as_utf8();
2477 JVM_END
2478 
2479 
2480 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))

2603   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2604   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2605   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2606   return method->size_of_parameters();
2607 JVM_END
2608 
2609 
2610 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2611   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2612   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2613   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2614   return method->verifier_max_stack();
2615 JVM_END
2616 
2617 
2618 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2619   ResourceMark rm(THREAD);
2620   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2621   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2622   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2623   return method->name() == vmSymbols::object_initializer_name();
2624 JVM_END
2625 
2626 
2627 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2628   ResourceMark rm(THREAD);
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->is_overpass();
2633 JVM_END
2634 
2635 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2636   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2637   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2638   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2639   return method->name()->as_utf8();
2640 JVM_END
2641 
2642 
2643 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))

3442 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3443   void* find_result = os::dll_lookup(handle, name);
3444   log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3445                     find_result != nullptr ? "Found" : "Failed to find",
3446                     name, p2i(handle));
3447   return find_result;
3448 JVM_END
3449 
3450 
3451 // JNI version ///////////////////////////////////////////////////////////////////////////////
3452 
3453 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3454   return Threads::is_supported_jni_version_including_1_1(version);
3455 JVM_END
3456 
3457 
3458 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3459   return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3460 JVM_END
3461 




3462 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3463   return VMContinuations ? JNI_TRUE : JNI_FALSE;
3464 JVM_END
3465 
3466 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3467   return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3468 JVM_END
3469 
3470 // String support ///////////////////////////////////////////////////////////////////////////
3471 
3472 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3473   JvmtiVMObjectAllocEventCollector oam;
3474   if (str == nullptr) return nullptr;
3475   oop string = JNIHandles::resolve_non_null(str);
3476   oop result = StringTable::intern(string, CHECK_NULL);
3477   return (jstring) JNIHandles::make_local(THREAD, result);
3478 JVM_END
3479 
3480 
3481 // VM Raw monitor support //////////////////////////////////////////////////////////////////////

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

3563   oop constructor_mirror = JNIHandles::resolve(c);
3564   objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3565   oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3566   jobject res = JNIHandles::make_local(THREAD, result);
3567   if (JvmtiExport::should_post_vm_object_alloc()) {
3568     JvmtiExport::post_vm_object_alloc(thread, result);
3569   }
3570   return res;
3571 JVM_END
3572 
3573 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3574 
3575 JVM_LEAF(jboolean, JVM_SupportsCX8())
3576   return VM_Version::supports_cx8();
3577 JVM_END
3578 
3579 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3580   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3581   assert(k->is_klass(), "just checking");
3582   HeapShared::initialize_from_archived_subgraph(THREAD, k);
3583 JVM_END
3584 

  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"

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

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

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

1857     int length = components->length();
1858     assert(length >= 0, "unexpected record_components length");
1859     objArrayOop record_components =
1860       oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1861     objArrayHandle components_h (THREAD, record_components);
1862 
1863     for (int x = 0; x < length; x++) {
1864       RecordComponent* component = components->at(x);
1865       assert(component != nullptr, "unexpected null record component");
1866       oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1867       components_h->obj_at_put(x, component_oop);
1868     }
1869     return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1870   }
1871 
1872   return nullptr;
1873 }
1874 JVM_END
1875 
1876 static bool select_method(const methodHandle& method, bool want_constructor) {
1877   bool is_ctor = (method->is_object_constructor() ||
1878                   method->is_static_vnew_factory());
1879   if (want_constructor) {
1880     return is_ctor;
1881   } else {
1882     return (!is_ctor &&
1883             !method->is_class_initializer() &&
1884             !method->is_overpass());
1885   }
1886 }
1887 
1888 static jobjectArray get_class_declared_methods_helper(
1889                                   JNIEnv *env,
1890                                   jclass ofClass, jboolean publicOnly,
1891                                   bool want_constructor,
1892                                   Klass* klass, TRAPS) {
1893 
1894   JvmtiVMObjectAllocEventCollector oam;
1895 
1896   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1897   // Exclude primitive types and array types
1898   if (java_lang_Class::is_primitive(ofMirror)
1899       || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1900     // Return empty array
1901     oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1902     return (jobjectArray) JNIHandles::make_local(THREAD, res);
1903   }
1904 

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

2211   constantTag tag = cp->tag_at(index);
2212   if (!tag.is_method() && !tag.is_interface_method()) {
2213     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2214   }
2215   int klass_ref  = cp->uncached_klass_ref_index_at(index);
2216   Klass* k_o;
2217   if (force_resolution) {
2218     k_o = cp->klass_at(klass_ref, CHECK_NULL);
2219   } else {
2220     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2221     if (k_o == nullptr) return nullptr;
2222   }
2223   InstanceKlass* k = InstanceKlass::cast(k_o);
2224   Symbol* name = cp->uncached_name_ref_at(index);
2225   Symbol* sig  = cp->uncached_signature_ref_at(index);
2226   methodHandle m (THREAD, k->find_method(name, sig));
2227   if (m.is_null()) {
2228     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2229   }
2230   oop method;
2231   if (m->is_object_constructor() || m->is_static_vnew_factory()) {


2232     method = Reflection::new_constructor(m, CHECK_NULL);
2233   } else {
2234     method = Reflection::new_method(m, true, CHECK_NULL);
2235   }
2236   return JNIHandles::make_local(THREAD, method);
2237 }
2238 
2239 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2240 {
2241   JvmtiVMObjectAllocEventCollector oam;
2242   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2243   bounds_check(cp, index, CHECK_NULL);
2244   jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2245   return res;
2246 }
2247 JVM_END
2248 
2249 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2250 {
2251   JvmtiVMObjectAllocEventCollector oam;
2252   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2253   bounds_check(cp, index, CHECK_NULL);
2254   jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);

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

2684   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2685   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2686   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2687   return method->size_of_parameters();
2688 JVM_END
2689 
2690 
2691 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2692   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2693   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2694   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2695   return method->verifier_max_stack();
2696 JVM_END
2697 
2698 
2699 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2700   ResourceMark rm(THREAD);
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->is_object_constructor();
2705 JVM_END
2706 
2707 
2708 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2709   ResourceMark rm(THREAD);
2710   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2711   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2712   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2713   return method->is_overpass();
2714 JVM_END
2715 
2716 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2717   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2718   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2719   Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2720   return method->name()->as_utf8();
2721 JVM_END
2722 
2723 
2724 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))

3523 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3524   void* find_result = os::dll_lookup(handle, name);
3525   log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3526                     find_result != nullptr ? "Found" : "Failed to find",
3527                     name, p2i(handle));
3528   return find_result;
3529 JVM_END
3530 
3531 
3532 // JNI version ///////////////////////////////////////////////////////////////////////////////
3533 
3534 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3535   return Threads::is_supported_jni_version_including_1_1(version);
3536 JVM_END
3537 
3538 
3539 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3540   return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3541 JVM_END
3542 
3543 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3544   return EnableValhalla ? JNI_TRUE : JNI_FALSE;
3545 JVM_END
3546 
3547 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3548   return VMContinuations ? JNI_TRUE : JNI_FALSE;
3549 JVM_END
3550 
3551 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3552   return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3553 JVM_END
3554 
3555 // String support ///////////////////////////////////////////////////////////////////////////
3556 
3557 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3558   JvmtiVMObjectAllocEventCollector oam;
3559   if (str == nullptr) return nullptr;
3560   oop string = JNIHandles::resolve_non_null(str);
3561   oop result = StringTable::intern(string, CHECK_NULL);
3562   return (jstring) JNIHandles::make_local(THREAD, result);
3563 JVM_END
3564 
3565 
3566 // VM Raw monitor support //////////////////////////////////////////////////////////////////////

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

3650   oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3651   jobject res = JNIHandles::make_local(THREAD, result);
3652   if (JvmtiExport::should_post_vm_object_alloc()) {
3653     JvmtiExport::post_vm_object_alloc(thread, result);
3654   }
3655   return res;
3656 JVM_END
3657 
3658 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3659 
3660 JVM_LEAF(jboolean, JVM_SupportsCX8())
3661   return VM_Version::supports_cx8();
3662 JVM_END
3663 
3664 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3665   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3666   assert(k->is_klass(), "just checking");
3667   HeapShared::initialize_from_archived_subgraph(THREAD, k);
3668 JVM_END
3669 
< prev index next >