1610 strcpy(info_ptr->name, name);
1611 } else {
1612 info_ptr->name = nullptr;
1613 }
1614
1615 return JVMTI_ERROR_NONE;
1616 } /* end GetThreadGroupInfo */
1617
1618 // thread_count_ptr - pre-checked for null
1619 // threads_ptr - pre-checked for null
1620 // group_count_ptr - pre-checked for null
1621 // groups_ptr - pre-checked for null
1622 jvmtiError
1623 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) {
1624 jvmtiError err;
1625 JavaThread* current_thread = JavaThread::current();
1626 oop group_obj = JNIHandles::resolve_external_guard(group);
1627 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP);
1628
1629 Handle *thread_objs = nullptr;
1630 objArrayHandle group_objs;
1631 jint nthreads = 0;
1632 jint ngroups = 0;
1633 int hidden_threads = 0;
1634
1635 ResourceMark rm(current_thread);
1636 HandleMark hm(current_thread);
1637
1638 Handle group_hdl(current_thread, group_obj);
1639
1640 err = get_live_threads(current_thread, group_hdl, &nthreads, &thread_objs);
1641 if (err != JVMTI_ERROR_NONE) {
1642 return err;
1643 }
1644 err = get_subgroups(current_thread, group_hdl, &ngroups, &group_objs);
1645 if (err != JVMTI_ERROR_NONE) {
1646 return err;
1647 }
1648
1649 *group_count_ptr = ngroups;
1650 *thread_count_ptr = nthreads;
2720
2721 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2722 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2723 {
2724 JavaThread* current_thread = JavaThread::current();
2725 ResourceMark rm(current_thread);
2726 const char* sfncp = (const char*) sfnOop->as_C_string();
2727 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2728 strcpy(*source_name_ptr, sfncp);
2729 }
2730
2731 return JVMTI_ERROR_NONE;
2732 } /* end GetSourceFileName */
2733
2734
2735 // k_mirror - may be primitive, this must be checked
2736 // modifiers_ptr - pre-checked for null
2737 jvmtiError
2738 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2739 jint result = java_lang_Class::modifiers(k_mirror);
2740 if (!java_lang_Class::is_primitive(k_mirror)) {
2741 // Reset the deleted ACC_SUPER bit (deleted in compute_modifier_flags()).
2742 result |= JVM_ACC_SUPER;
2743 }
2744 *modifiers_ptr = result;
2745
2746 return JVMTI_ERROR_NONE;
2747 } /* end GetClassModifiers */
2748
2749
2750 // k_mirror - may be primitive, this must be checked
2751 // method_count_ptr - pre-checked for null
2752 // methods_ptr - pre-checked for null
2753 jvmtiError
2754 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2755 JavaThread* current_thread = JavaThread::current();
2756 HandleMark hm(current_thread);
2757
2758 if (java_lang_Class::is_primitive(k_mirror)) {
2759 *method_count_ptr = 0;
2760 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2841 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2842 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2843 }
2844
2845 if (!k->is_instance_klass()) {
2846 *field_count_ptr = 0;
2847 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2848 return JVMTI_ERROR_NONE;
2849 }
2850
2851 InstanceKlass* ik = InstanceKlass::cast(k);
2852
2853 JavaFieldStream flds(ik);
2854
2855 int result_count = ik->java_fields_count();
2856
2857 // Allocate the result and fill it in.
2858 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2859 for (int i = 0; i < result_count; i++, flds.next()) {
2860 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2861 flds.access_flags().is_static());
2862 }
2863 assert(flds.done(), "just checking");
2864
2865 // Fill in the results
2866 *field_count_ptr = result_count;
2867 *fields_ptr = result_list;
2868
2869 return JVMTI_ERROR_NONE;
2870 } /* end GetClassFields */
2871
2872
2873 // k_mirror - may be primitive, this must be checked
2874 // interface_count_ptr - pre-checked for null
2875 // interfaces_ptr - pre-checked for null
2876 jvmtiError
2877 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2878 {
2879 if (java_lang_Class::is_primitive(k_mirror)) {
2880 *interface_count_ptr = 0;
2881 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2882 return JVMTI_ERROR_NONE;
2883 }
2884 JavaThread* current_thread = JavaThread::current();
2885 HandleMark hm(current_thread);
2886 Klass* k = java_lang_Class::as_Klass(k_mirror);
2887 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2888
2889 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2890 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2891 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2892
2893 if (!k->is_instance_klass()) {
2894 *interface_count_ptr = 0;
2895 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2896 return JVMTI_ERROR_NONE;
2897 }
2898
2899 Array<InstanceKlass*>* interface_list = InstanceKlass::cast(k)->local_interfaces();
2900 const int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2901 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2902 for (int i_index = 0; i_index < result_length; i_index += 1) {
2903 InstanceKlass* klass_at = interface_list->at(i_index);
2904 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2905 assert(klass_at->is_interface(), "interfaces must be interfaces");
2906 oop mirror_at = klass_at->java_mirror();
2907 Handle handle_at = Handle(current_thread, mirror_at);
2908 result_list[i_index] = (jclass) jni_reference(handle_at);
2909 }
2910 *interface_count_ptr = result_length;
2911 *interfaces_ptr = result_list;
2912 }
2913
2914 return JVMTI_ERROR_NONE;
2915 } /* end GetImplementedInterfaces */
2916
2917
2918 // k_mirror - may be primitive, this must be checked
2919 // minor_version_ptr - pre-checked for null
2920 // major_version_ptr - pre-checked for null
3076 {
3077 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3078 strcpy(*source_debug_extension_ptr, sde);
3079 }
3080 }
3081
3082 return JVMTI_ERROR_NONE;
3083 } /* end GetSourceDebugExtension */
3084
3085 //
3086 // Object functions
3087 //
3088
3089 // hash_code_ptr - pre-checked for null
3090 jvmtiError
3091 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3092 oop mirror = JNIHandles::resolve_external_guard(object);
3093 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3094 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3095
3096 {
3097 jint result = (jint) mirror->identity_hash();
3098 *hash_code_ptr = result;
3099 }
3100 return JVMTI_ERROR_NONE;
3101 } /* end GetObjectHashCode */
3102
3103
3104 // info_ptr - pre-checked for null
3105 jvmtiError
3106 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3107 // This needs to be performed at a safepoint to gather stable data
3108 // because monitor owner / waiters might not be suspended.
3109 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3110 VMThread::execute(&op);
3111 return op.result();
3112 } /* end GetObjectMonitorUsage */
3113
3114
3115 //
3116 // Field functions
3117 //
3118
|
1610 strcpy(info_ptr->name, name);
1611 } else {
1612 info_ptr->name = nullptr;
1613 }
1614
1615 return JVMTI_ERROR_NONE;
1616 } /* end GetThreadGroupInfo */
1617
1618 // thread_count_ptr - pre-checked for null
1619 // threads_ptr - pre-checked for null
1620 // group_count_ptr - pre-checked for null
1621 // groups_ptr - pre-checked for null
1622 jvmtiError
1623 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) {
1624 jvmtiError err;
1625 JavaThread* current_thread = JavaThread::current();
1626 oop group_obj = JNIHandles::resolve_external_guard(group);
1627 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP);
1628
1629 Handle *thread_objs = nullptr;
1630 refArrayHandle group_objs;
1631 jint nthreads = 0;
1632 jint ngroups = 0;
1633 int hidden_threads = 0;
1634
1635 ResourceMark rm(current_thread);
1636 HandleMark hm(current_thread);
1637
1638 Handle group_hdl(current_thread, group_obj);
1639
1640 err = get_live_threads(current_thread, group_hdl, &nthreads, &thread_objs);
1641 if (err != JVMTI_ERROR_NONE) {
1642 return err;
1643 }
1644 err = get_subgroups(current_thread, group_hdl, &ngroups, &group_objs);
1645 if (err != JVMTI_ERROR_NONE) {
1646 return err;
1647 }
1648
1649 *group_count_ptr = ngroups;
1650 *thread_count_ptr = nthreads;
2720
2721 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2722 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2723 {
2724 JavaThread* current_thread = JavaThread::current();
2725 ResourceMark rm(current_thread);
2726 const char* sfncp = (const char*) sfnOop->as_C_string();
2727 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2728 strcpy(*source_name_ptr, sfncp);
2729 }
2730
2731 return JVMTI_ERROR_NONE;
2732 } /* end GetSourceFileName */
2733
2734
2735 // k_mirror - may be primitive, this must be checked
2736 // modifiers_ptr - pre-checked for null
2737 jvmtiError
2738 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2739 jint result = java_lang_Class::modifiers(k_mirror);
2740 if (!Arguments::is_valhalla_enabled() && !java_lang_Class::is_primitive(k_mirror)) {
2741 // Reset the deleted ACC_SUPER bit (deleted in compute_modifier_flags()).
2742 result |= JVM_ACC_SUPER;
2743 }
2744 *modifiers_ptr = result;
2745
2746 return JVMTI_ERROR_NONE;
2747 } /* end GetClassModifiers */
2748
2749
2750 // k_mirror - may be primitive, this must be checked
2751 // method_count_ptr - pre-checked for null
2752 // methods_ptr - pre-checked for null
2753 jvmtiError
2754 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2755 JavaThread* current_thread = JavaThread::current();
2756 HandleMark hm(current_thread);
2757
2758 if (java_lang_Class::is_primitive(k_mirror)) {
2759 *method_count_ptr = 0;
2760 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2841 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2842 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2843 }
2844
2845 if (!k->is_instance_klass()) {
2846 *field_count_ptr = 0;
2847 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2848 return JVMTI_ERROR_NONE;
2849 }
2850
2851 InstanceKlass* ik = InstanceKlass::cast(k);
2852
2853 JavaFieldStream flds(ik);
2854
2855 int result_count = ik->java_fields_count();
2856
2857 // Allocate the result and fill it in.
2858 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2859 for (int i = 0; i < result_count; i++, flds.next()) {
2860 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2861 flds.access_flags().is_static(),
2862 flds.field_descriptor().is_flat());
2863 }
2864 assert(flds.done(), "just checking");
2865
2866 // Fill in the results
2867 *field_count_ptr = result_count;
2868 *fields_ptr = result_list;
2869
2870 return JVMTI_ERROR_NONE;
2871 } /* end GetClassFields */
2872
2873
2874 // k_mirror - may be primitive, this must be checked
2875 // interface_count_ptr - pre-checked for null
2876 // interfaces_ptr - pre-checked for null
2877 jvmtiError
2878 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2879 {
2880 if (java_lang_Class::is_primitive(k_mirror)) {
2881 *interface_count_ptr = 0;
2882 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2883 return JVMTI_ERROR_NONE;
2884 }
2885 JavaThread* current_thread = JavaThread::current();
2886 HandleMark hm(current_thread);
2887 Klass* k = java_lang_Class::as_Klass(k_mirror);
2888 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2889
2890 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2891 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2892 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2893
2894 if (!k->is_instance_klass()) {
2895 *interface_count_ptr = 0;
2896 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2897 return JVMTI_ERROR_NONE;
2898 }
2899
2900 InstanceKlass* ik = InstanceKlass::cast(k);
2901 Array<InstanceKlass*>* interface_list = ik->local_interfaces();
2902 int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2903 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2904 for (int i_index = 0; i_index < result_length; i_index += 1) {
2905 InstanceKlass* klass_at = interface_list->at(i_index);
2906 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2907 assert(klass_at->is_interface(), "interfaces must be interfaces");
2908 oop mirror_at = klass_at->java_mirror();
2909 Handle handle_at = Handle(current_thread, mirror_at);
2910 result_list[i_index] = (jclass) jni_reference(handle_at);
2911 }
2912 *interface_count_ptr = result_length;
2913 *interfaces_ptr = result_list;
2914 }
2915
2916 return JVMTI_ERROR_NONE;
2917 } /* end GetImplementedInterfaces */
2918
2919
2920 // k_mirror - may be primitive, this must be checked
2921 // minor_version_ptr - pre-checked for null
2922 // major_version_ptr - pre-checked for null
3078 {
3079 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3080 strcpy(*source_debug_extension_ptr, sde);
3081 }
3082 }
3083
3084 return JVMTI_ERROR_NONE;
3085 } /* end GetSourceDebugExtension */
3086
3087 //
3088 // Object functions
3089 //
3090
3091 // hash_code_ptr - pre-checked for null
3092 jvmtiError
3093 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3094 oop mirror = JNIHandles::resolve_external_guard(object);
3095 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3096 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3097
3098 if (mirror->is_inline_type()) {
3099 // For inline types, use the klass as a hash code.
3100 // TBD to improve this (see also JvmtiTagMapKey::get_hash for similar case).
3101 *hash_code_ptr = (jint)((int64_t)mirror->klass() >> 3);
3102 } else {
3103 *hash_code_ptr = (jint)mirror->identity_hash();
3104 }
3105 return JVMTI_ERROR_NONE;
3106 } /* end GetObjectHashCode */
3107
3108
3109 // info_ptr - pre-checked for null
3110 jvmtiError
3111 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3112 // This needs to be performed at a safepoint to gather stable data
3113 // because monitor owner / waiters might not be suspended.
3114 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3115 VMThread::execute(&op);
3116 return op.result();
3117 } /* end GetObjectMonitorUsage */
3118
3119
3120 //
3121 // Field functions
3122 //
3123
|