1588 strcpy(info_ptr->name, name);
1589 } else {
1590 info_ptr->name = nullptr;
1591 }
1592
1593 return JVMTI_ERROR_NONE;
1594 } /* end GetThreadGroupInfo */
1595
1596 // thread_count_ptr - pre-checked for null
1597 // threads_ptr - pre-checked for null
1598 // group_count_ptr - pre-checked for null
1599 // groups_ptr - pre-checked for null
1600 jvmtiError
1601 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) {
1602 jvmtiError err;
1603 JavaThread* current_thread = JavaThread::current();
1604 oop group_obj = JNIHandles::resolve_external_guard(group);
1605 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP);
1606
1607 Handle *thread_objs = nullptr;
1608 objArrayHandle group_objs;
1609 jint nthreads = 0;
1610 jint ngroups = 0;
1611 int hidden_threads = 0;
1612
1613 ResourceMark rm(current_thread);
1614 HandleMark hm(current_thread);
1615
1616 Handle group_hdl(current_thread, group_obj);
1617
1618 err = get_live_threads(current_thread, group_hdl, &nthreads, &thread_objs);
1619 if (err != JVMTI_ERROR_NONE) {
1620 return err;
1621 }
1622 err = get_subgroups(current_thread, group_hdl, &ngroups, &group_objs);
1623 if (err != JVMTI_ERROR_NONE) {
1624 return err;
1625 }
1626
1627 *group_count_ptr = ngroups;
1628 *thread_count_ptr = nthreads;
2698
2699 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2700 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2701 {
2702 JavaThread* current_thread = JavaThread::current();
2703 ResourceMark rm(current_thread);
2704 const char* sfncp = (const char*) sfnOop->as_C_string();
2705 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2706 strcpy(*source_name_ptr, sfncp);
2707 }
2708
2709 return JVMTI_ERROR_NONE;
2710 } /* end GetSourceFileName */
2711
2712
2713 // k_mirror - may be primitive, this must be checked
2714 // modifiers_ptr - pre-checked for null
2715 jvmtiError
2716 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2717 jint result = java_lang_Class::modifiers(k_mirror);
2718 if (!java_lang_Class::is_primitive(k_mirror)) {
2719 // Reset the deleted ACC_SUPER bit (deleted in compute_modifier_flags()).
2720 result |= JVM_ACC_SUPER;
2721 }
2722 *modifiers_ptr = result;
2723
2724 return JVMTI_ERROR_NONE;
2725 } /* end GetClassModifiers */
2726
2727
2728 // k_mirror - may be primitive, this must be checked
2729 // method_count_ptr - pre-checked for null
2730 // methods_ptr - pre-checked for null
2731 jvmtiError
2732 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2733 JavaThread* current_thread = JavaThread::current();
2734 HandleMark hm(current_thread);
2735
2736 if (java_lang_Class::is_primitive(k_mirror)) {
2737 *method_count_ptr = 0;
2738 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2819 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2820 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2821 }
2822
2823 if (!k->is_instance_klass()) {
2824 *field_count_ptr = 0;
2825 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2826 return JVMTI_ERROR_NONE;
2827 }
2828
2829 InstanceKlass* ik = InstanceKlass::cast(k);
2830
2831 JavaFieldStream flds(ik);
2832
2833 int result_count = ik->java_fields_count();
2834
2835 // Allocate the result and fill it in.
2836 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2837 for (int i = 0; i < result_count; i++, flds.next()) {
2838 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2839 flds.access_flags().is_static());
2840 }
2841 assert(flds.done(), "just checking");
2842
2843 // Fill in the results
2844 *field_count_ptr = result_count;
2845 *fields_ptr = result_list;
2846
2847 return JVMTI_ERROR_NONE;
2848 } /* end GetClassFields */
2849
2850
2851 // k_mirror - may be primitive, this must be checked
2852 // interface_count_ptr - pre-checked for null
2853 // interfaces_ptr - pre-checked for null
2854 jvmtiError
2855 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2856 {
2857 if (java_lang_Class::is_primitive(k_mirror)) {
2858 *interface_count_ptr = 0;
2859 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2860 return JVMTI_ERROR_NONE;
2861 }
2862 JavaThread* current_thread = JavaThread::current();
2863 HandleMark hm(current_thread);
2864 Klass* k = java_lang_Class::as_Klass(k_mirror);
2865 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2866
2867 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2868 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2869 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2870
2871 if (!k->is_instance_klass()) {
2872 *interface_count_ptr = 0;
2873 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2874 return JVMTI_ERROR_NONE;
2875 }
2876
2877 Array<InstanceKlass*>* interface_list = InstanceKlass::cast(k)->local_interfaces();
2878 const int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2879 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2880 for (int i_index = 0; i_index < result_length; i_index += 1) {
2881 InstanceKlass* klass_at = interface_list->at(i_index);
2882 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2883 assert(klass_at->is_interface(), "interfaces must be interfaces");
2884 oop mirror_at = klass_at->java_mirror();
2885 Handle handle_at = Handle(current_thread, mirror_at);
2886 result_list[i_index] = (jclass) jni_reference(handle_at);
2887 }
2888 *interface_count_ptr = result_length;
2889 *interfaces_ptr = result_list;
2890 }
2891
2892 return JVMTI_ERROR_NONE;
2893 } /* end GetImplementedInterfaces */
2894
2895
2896 // k_mirror - may be primitive, this must be checked
2897 // minor_version_ptr - pre-checked for null
2898 // major_version_ptr - pre-checked for null
3054 {
3055 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3056 strcpy(*source_debug_extension_ptr, sde);
3057 }
3058 }
3059
3060 return JVMTI_ERROR_NONE;
3061 } /* end GetSourceDebugExtension */
3062
3063 //
3064 // Object functions
3065 //
3066
3067 // hash_code_ptr - pre-checked for null
3068 jvmtiError
3069 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3070 oop mirror = JNIHandles::resolve_external_guard(object);
3071 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3072 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3073
3074 {
3075 jint result = (jint) mirror->identity_hash();
3076 *hash_code_ptr = result;
3077 }
3078 return JVMTI_ERROR_NONE;
3079 } /* end GetObjectHashCode */
3080
3081
3082 // info_ptr - pre-checked for null
3083 jvmtiError
3084 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3085 // This needs to be performed at a safepoint to gather stable data
3086 // because monitor owner / waiters might not be suspended.
3087 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3088 VMThread::execute(&op);
3089 return op.result();
3090 } /* end GetObjectMonitorUsage */
3091
3092
3093 //
3094 // Field functions
3095 //
3096
|
1588 strcpy(info_ptr->name, name);
1589 } else {
1590 info_ptr->name = nullptr;
1591 }
1592
1593 return JVMTI_ERROR_NONE;
1594 } /* end GetThreadGroupInfo */
1595
1596 // thread_count_ptr - pre-checked for null
1597 // threads_ptr - pre-checked for null
1598 // group_count_ptr - pre-checked for null
1599 // groups_ptr - pre-checked for null
1600 jvmtiError
1601 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) {
1602 jvmtiError err;
1603 JavaThread* current_thread = JavaThread::current();
1604 oop group_obj = JNIHandles::resolve_external_guard(group);
1605 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP);
1606
1607 Handle *thread_objs = nullptr;
1608 refArrayHandle group_objs;
1609 jint nthreads = 0;
1610 jint ngroups = 0;
1611 int hidden_threads = 0;
1612
1613 ResourceMark rm(current_thread);
1614 HandleMark hm(current_thread);
1615
1616 Handle group_hdl(current_thread, group_obj);
1617
1618 err = get_live_threads(current_thread, group_hdl, &nthreads, &thread_objs);
1619 if (err != JVMTI_ERROR_NONE) {
1620 return err;
1621 }
1622 err = get_subgroups(current_thread, group_hdl, &ngroups, &group_objs);
1623 if (err != JVMTI_ERROR_NONE) {
1624 return err;
1625 }
1626
1627 *group_count_ptr = ngroups;
1628 *thread_count_ptr = nthreads;
2698
2699 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2700 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2701 {
2702 JavaThread* current_thread = JavaThread::current();
2703 ResourceMark rm(current_thread);
2704 const char* sfncp = (const char*) sfnOop->as_C_string();
2705 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2706 strcpy(*source_name_ptr, sfncp);
2707 }
2708
2709 return JVMTI_ERROR_NONE;
2710 } /* end GetSourceFileName */
2711
2712
2713 // k_mirror - may be primitive, this must be checked
2714 // modifiers_ptr - pre-checked for null
2715 jvmtiError
2716 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2717 jint result = java_lang_Class::modifiers(k_mirror);
2718 if (!Arguments::is_valhalla_enabled() && !java_lang_Class::is_primitive(k_mirror)) {
2719 // Reset the deleted ACC_SUPER bit (deleted in compute_modifier_flags()).
2720 result |= JVM_ACC_SUPER;
2721 }
2722 *modifiers_ptr = result;
2723
2724 return JVMTI_ERROR_NONE;
2725 } /* end GetClassModifiers */
2726
2727
2728 // k_mirror - may be primitive, this must be checked
2729 // method_count_ptr - pre-checked for null
2730 // methods_ptr - pre-checked for null
2731 jvmtiError
2732 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2733 JavaThread* current_thread = JavaThread::current();
2734 HandleMark hm(current_thread);
2735
2736 if (java_lang_Class::is_primitive(k_mirror)) {
2737 *method_count_ptr = 0;
2738 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2819 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2820 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2821 }
2822
2823 if (!k->is_instance_klass()) {
2824 *field_count_ptr = 0;
2825 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2826 return JVMTI_ERROR_NONE;
2827 }
2828
2829 InstanceKlass* ik = InstanceKlass::cast(k);
2830
2831 JavaFieldStream flds(ik);
2832
2833 int result_count = ik->java_fields_count();
2834
2835 // Allocate the result and fill it in.
2836 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2837 for (int i = 0; i < result_count; i++, flds.next()) {
2838 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2839 flds.access_flags().is_static(),
2840 flds.field_descriptor().is_flat());
2841 }
2842 assert(flds.done(), "just checking");
2843
2844 // Fill in the results
2845 *field_count_ptr = result_count;
2846 *fields_ptr = result_list;
2847
2848 return JVMTI_ERROR_NONE;
2849 } /* end GetClassFields */
2850
2851
2852 // k_mirror - may be primitive, this must be checked
2853 // interface_count_ptr - pre-checked for null
2854 // interfaces_ptr - pre-checked for null
2855 jvmtiError
2856 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2857 {
2858 if (java_lang_Class::is_primitive(k_mirror)) {
2859 *interface_count_ptr = 0;
2860 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2861 return JVMTI_ERROR_NONE;
2862 }
2863 JavaThread* current_thread = JavaThread::current();
2864 HandleMark hm(current_thread);
2865 Klass* k = java_lang_Class::as_Klass(k_mirror);
2866 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2867
2868 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2869 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2870 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2871
2872 if (!k->is_instance_klass()) {
2873 *interface_count_ptr = 0;
2874 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2875 return JVMTI_ERROR_NONE;
2876 }
2877
2878 InstanceKlass* ik = InstanceKlass::cast(k);
2879 Array<InstanceKlass*>* interface_list = ik->local_interfaces();
2880 int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2881 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2882 for (int i_index = 0; i_index < result_length; i_index += 1) {
2883 InstanceKlass* klass_at = interface_list->at(i_index);
2884 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2885 assert(klass_at->is_interface(), "interfaces must be interfaces");
2886 oop mirror_at = klass_at->java_mirror();
2887 Handle handle_at = Handle(current_thread, mirror_at);
2888 result_list[i_index] = (jclass) jni_reference(handle_at);
2889 }
2890 *interface_count_ptr = result_length;
2891 *interfaces_ptr = result_list;
2892 }
2893
2894 return JVMTI_ERROR_NONE;
2895 } /* end GetImplementedInterfaces */
2896
2897
2898 // k_mirror - may be primitive, this must be checked
2899 // minor_version_ptr - pre-checked for null
2900 // major_version_ptr - pre-checked for null
3056 {
3057 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3058 strcpy(*source_debug_extension_ptr, sde);
3059 }
3060 }
3061
3062 return JVMTI_ERROR_NONE;
3063 } /* end GetSourceDebugExtension */
3064
3065 //
3066 // Object functions
3067 //
3068
3069 // hash_code_ptr - pre-checked for null
3070 jvmtiError
3071 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3072 oop mirror = JNIHandles::resolve_external_guard(object);
3073 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3074 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3075
3076 if (mirror->is_inline_type()) {
3077 // For inline types, use the klass as a hash code.
3078 // TBD to improve this (see also JvmtiTagMapKey::get_hash for similar case).
3079 *hash_code_ptr = (jint)((int64_t)mirror->klass() >> 3);
3080 } else {
3081 *hash_code_ptr = (jint)mirror->identity_hash();
3082 }
3083 return JVMTI_ERROR_NONE;
3084 } /* end GetObjectHashCode */
3085
3086
3087 // info_ptr - pre-checked for null
3088 jvmtiError
3089 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3090 // This needs to be performed at a safepoint to gather stable data
3091 // because monitor owner / waiters might not be suspended.
3092 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3093 VMThread::execute(&op);
3094 return op.result();
3095 } /* end GetObjectMonitorUsage */
3096
3097
3098 //
3099 // Field functions
3100 //
3101
|