2710
2711 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2712 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2713 {
2714 JavaThread* current_thread = JavaThread::current();
2715 ResourceMark rm(current_thread);
2716 const char* sfncp = (const char*) sfnOop->as_C_string();
2717 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2718 strcpy(*source_name_ptr, sfncp);
2719 }
2720
2721 return JVMTI_ERROR_NONE;
2722 } /* end GetSourceFileName */
2723
2724
2725 // k_mirror - may be primitive, this must be checked
2726 // modifiers_ptr - pre-checked for null
2727 jvmtiError
2728 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2729 jint result = java_lang_Class::modifiers(k_mirror);
2730 if (!java_lang_Class::is_primitive(k_mirror)) {
2731 // Reset the deleted ACC_SUPER bit (deleted in compute_modifier_flags()).
2732 result |= JVM_ACC_SUPER;
2733 }
2734 *modifiers_ptr = result;
2735
2736 return JVMTI_ERROR_NONE;
2737 } /* end GetClassModifiers */
2738
2739
2740 // k_mirror - may be primitive, this must be checked
2741 // method_count_ptr - pre-checked for null
2742 // methods_ptr - pre-checked for null
2743 jvmtiError
2744 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2745 JavaThread* current_thread = JavaThread::current();
2746 HandleMark hm(current_thread);
2747
2748 if (java_lang_Class::is_primitive(k_mirror)) {
2749 *method_count_ptr = 0;
2750 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2751 return JVMTI_ERROR_NONE;
2752 }
2753 Klass* k = java_lang_Class::as_Klass(k_mirror);
2831 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2832 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2833 }
2834
2835 if (!k->is_instance_klass()) {
2836 *field_count_ptr = 0;
2837 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2838 return JVMTI_ERROR_NONE;
2839 }
2840
2841 InstanceKlass* ik = InstanceKlass::cast(k);
2842
2843 FilteredJavaFieldStream flds(ik);
2844
2845 int result_count = flds.field_count();
2846
2847 // Allocate the result and fill it in.
2848 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2849 for (int i = 0; i < result_count; i++, flds.next()) {
2850 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2851 flds.access_flags().is_static());
2852 }
2853 assert(flds.done(), "just checking");
2854
2855 // Fill in the results
2856 *field_count_ptr = result_count;
2857 *fields_ptr = result_list;
2858
2859 return JVMTI_ERROR_NONE;
2860 } /* end GetClassFields */
2861
2862
2863 // k_mirror - may be primitive, this must be checked
2864 // interface_count_ptr - pre-checked for null
2865 // interfaces_ptr - pre-checked for null
2866 jvmtiError
2867 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2868 {
2869 if (java_lang_Class::is_primitive(k_mirror)) {
2870 *interface_count_ptr = 0;
2871 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2872 return JVMTI_ERROR_NONE;
2873 }
2874 JavaThread* current_thread = JavaThread::current();
2875 HandleMark hm(current_thread);
2876 Klass* k = java_lang_Class::as_Klass(k_mirror);
2877 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2878
2879 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2880 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2881 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2882
2883 if (!k->is_instance_klass()) {
2884 *interface_count_ptr = 0;
2885 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2886 return JVMTI_ERROR_NONE;
2887 }
2888
2889 Array<InstanceKlass*>* interface_list = InstanceKlass::cast(k)->local_interfaces();
2890 const int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2891 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2892 for (int i_index = 0; i_index < result_length; i_index += 1) {
2893 InstanceKlass* klass_at = interface_list->at(i_index);
2894 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2895 assert(klass_at->is_interface(), "interfaces must be interfaces");
2896 oop mirror_at = klass_at->java_mirror();
2897 Handle handle_at = Handle(current_thread, mirror_at);
2898 result_list[i_index] = (jclass) jni_reference(handle_at);
2899 }
2900 *interface_count_ptr = result_length;
2901 *interfaces_ptr = result_list;
2902 }
2903
2904 return JVMTI_ERROR_NONE;
2905 } /* end GetImplementedInterfaces */
2906
2907
2908 // k_mirror - may be primitive, this must be checked
2909 // minor_version_ptr - pre-checked for null
2910 // major_version_ptr - pre-checked for null
3066 {
3067 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3068 strcpy(*source_debug_extension_ptr, sde);
3069 }
3070 }
3071
3072 return JVMTI_ERROR_NONE;
3073 } /* end GetSourceDebugExtension */
3074
3075 //
3076 // Object functions
3077 //
3078
3079 // hash_code_ptr - pre-checked for null
3080 jvmtiError
3081 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3082 oop mirror = JNIHandles::resolve_external_guard(object);
3083 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3084 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3085
3086 {
3087 jint result = (jint) mirror->identity_hash();
3088 *hash_code_ptr = result;
3089 }
3090 return JVMTI_ERROR_NONE;
3091 } /* end GetObjectHashCode */
3092
3093
3094 // info_ptr - pre-checked for null
3095 jvmtiError
3096 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3097 // This needs to be performed at a safepoint to gather stable data
3098 // because monitor owner / waiters might not be suspended.
3099 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3100 VMThread::execute(&op);
3101 return op.result();
3102 } /* end GetObjectMonitorUsage */
3103
3104
3105 //
3106 // Field functions
3107 //
3108
|
2710
2711 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2712 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2713 {
2714 JavaThread* current_thread = JavaThread::current();
2715 ResourceMark rm(current_thread);
2716 const char* sfncp = (const char*) sfnOop->as_C_string();
2717 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2718 strcpy(*source_name_ptr, sfncp);
2719 }
2720
2721 return JVMTI_ERROR_NONE;
2722 } /* end GetSourceFileName */
2723
2724
2725 // k_mirror - may be primitive, this must be checked
2726 // modifiers_ptr - pre-checked for null
2727 jvmtiError
2728 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2729 jint result = java_lang_Class::modifiers(k_mirror);
2730 *modifiers_ptr = result;
2731
2732 return JVMTI_ERROR_NONE;
2733 } /* end GetClassModifiers */
2734
2735
2736 // k_mirror - may be primitive, this must be checked
2737 // method_count_ptr - pre-checked for null
2738 // methods_ptr - pre-checked for null
2739 jvmtiError
2740 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2741 JavaThread* current_thread = JavaThread::current();
2742 HandleMark hm(current_thread);
2743
2744 if (java_lang_Class::is_primitive(k_mirror)) {
2745 *method_count_ptr = 0;
2746 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2747 return JVMTI_ERROR_NONE;
2748 }
2749 Klass* k = java_lang_Class::as_Klass(k_mirror);
2827 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2828 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2829 }
2830
2831 if (!k->is_instance_klass()) {
2832 *field_count_ptr = 0;
2833 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2834 return JVMTI_ERROR_NONE;
2835 }
2836
2837 InstanceKlass* ik = InstanceKlass::cast(k);
2838
2839 FilteredJavaFieldStream flds(ik);
2840
2841 int result_count = flds.field_count();
2842
2843 // Allocate the result and fill it in.
2844 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2845 for (int i = 0; i < result_count; i++, flds.next()) {
2846 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2847 flds.access_flags().is_static(),
2848 flds.field_descriptor().is_flat());
2849 }
2850 assert(flds.done(), "just checking");
2851
2852 // Fill in the results
2853 *field_count_ptr = result_count;
2854 *fields_ptr = result_list;
2855
2856 return JVMTI_ERROR_NONE;
2857 } /* end GetClassFields */
2858
2859
2860 // k_mirror - may be primitive, this must be checked
2861 // interface_count_ptr - pre-checked for null
2862 // interfaces_ptr - pre-checked for null
2863 jvmtiError
2864 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2865 {
2866 if (java_lang_Class::is_primitive(k_mirror)) {
2867 *interface_count_ptr = 0;
2868 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2869 return JVMTI_ERROR_NONE;
2870 }
2871 JavaThread* current_thread = JavaThread::current();
2872 HandleMark hm(current_thread);
2873 Klass* k = java_lang_Class::as_Klass(k_mirror);
2874 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2875
2876 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2877 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2878 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2879
2880 if (!k->is_instance_klass()) {
2881 *interface_count_ptr = 0;
2882 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2883 return JVMTI_ERROR_NONE;
2884 }
2885
2886 InstanceKlass* ik = InstanceKlass::cast(k);
2887 Array<InstanceKlass*>* interface_list = ik->local_interfaces();
2888 int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2889 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2890 for (int i_index = 0; i_index < result_length; i_index += 1) {
2891 InstanceKlass* klass_at = interface_list->at(i_index);
2892 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2893 assert(klass_at->is_interface(), "interfaces must be interfaces");
2894 oop mirror_at = klass_at->java_mirror();
2895 Handle handle_at = Handle(current_thread, mirror_at);
2896 result_list[i_index] = (jclass) jni_reference(handle_at);
2897 }
2898 *interface_count_ptr = result_length;
2899 *interfaces_ptr = result_list;
2900 }
2901
2902 return JVMTI_ERROR_NONE;
2903 } /* end GetImplementedInterfaces */
2904
2905
2906 // k_mirror - may be primitive, this must be checked
2907 // minor_version_ptr - pre-checked for null
2908 // major_version_ptr - pre-checked for null
3064 {
3065 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3066 strcpy(*source_debug_extension_ptr, sde);
3067 }
3068 }
3069
3070 return JVMTI_ERROR_NONE;
3071 } /* end GetSourceDebugExtension */
3072
3073 //
3074 // Object functions
3075 //
3076
3077 // hash_code_ptr - pre-checked for null
3078 jvmtiError
3079 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3080 oop mirror = JNIHandles::resolve_external_guard(object);
3081 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3082 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3083
3084 if (mirror->is_inline_type()) {
3085 // For inline types, use the klass as a hash code.
3086 // TBD to improve this (see also JvmtiTagMapKey::get_hash for similar case).
3087 *hash_code_ptr = (jint)((int64_t)mirror->klass() >> 3);
3088 } else {
3089 *hash_code_ptr = (jint)mirror->identity_hash();
3090 }
3091 return JVMTI_ERROR_NONE;
3092 } /* end GetObjectHashCode */
3093
3094
3095 // info_ptr - pre-checked for null
3096 jvmtiError
3097 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3098 // This needs to be performed at a safepoint to gather stable data
3099 // because monitor owner / waiters might not be suspended.
3100 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3101 VMThread::execute(&op);
3102 return op.result();
3103 } /* end GetObjectMonitorUsage */
3104
3105
3106 //
3107 // Field functions
3108 //
3109
|