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);
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 FilteredJavaFieldStream flds(ik);
2854
2855 int result_count = flds.field_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
|
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);
2837 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2838 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2839 }
2840
2841 if (!k->is_instance_klass()) {
2842 *field_count_ptr = 0;
2843 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2844 return JVMTI_ERROR_NONE;
2845 }
2846
2847 InstanceKlass* ik = InstanceKlass::cast(k);
2848
2849 FilteredJavaFieldStream flds(ik);
2850
2851 int result_count = flds.field_count();
2852
2853 // Allocate the result and fill it in.
2854 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2855 for (int i = 0; i < result_count; i++, flds.next()) {
2856 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2857 flds.access_flags().is_static(),
2858 flds.field_descriptor().is_flat());
2859 }
2860 assert(flds.done(), "just checking");
2861
2862 // Fill in the results
2863 *field_count_ptr = result_count;
2864 *fields_ptr = result_list;
2865
2866 return JVMTI_ERROR_NONE;
2867 } /* end GetClassFields */
2868
2869
2870 // k_mirror - may be primitive, this must be checked
2871 // interface_count_ptr - pre-checked for null
2872 // interfaces_ptr - pre-checked for null
2873 jvmtiError
2874 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2875 {
2876 if (java_lang_Class::is_primitive(k_mirror)) {
2877 *interface_count_ptr = 0;
2878 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2879 return JVMTI_ERROR_NONE;
2880 }
2881 JavaThread* current_thread = JavaThread::current();
2882 HandleMark hm(current_thread);
2883 Klass* k = java_lang_Class::as_Klass(k_mirror);
2884 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2885
2886 // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2887 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2888 return JVMTI_ERROR_CLASS_NOT_PREPARED;
2889
2890 if (!k->is_instance_klass()) {
2891 *interface_count_ptr = 0;
2892 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2893 return JVMTI_ERROR_NONE;
2894 }
2895
2896 InstanceKlass* ik = InstanceKlass::cast(k);
2897 Array<InstanceKlass*>* interface_list = ik->local_interfaces();
2898 int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2899 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2900 for (int i_index = 0; i_index < result_length; i_index += 1) {
2901 InstanceKlass* klass_at = interface_list->at(i_index);
2902 assert(klass_at->is_klass(), "interfaces must be Klass*s");
2903 assert(klass_at->is_interface(), "interfaces must be interfaces");
2904 oop mirror_at = klass_at->java_mirror();
2905 Handle handle_at = Handle(current_thread, mirror_at);
2906 result_list[i_index] = (jclass) jni_reference(handle_at);
2907 }
2908 *interface_count_ptr = result_length;
2909 *interfaces_ptr = result_list;
2910 }
2911
2912 return JVMTI_ERROR_NONE;
2913 } /* end GetImplementedInterfaces */
2914
2915
2916 // k_mirror - may be primitive, this must be checked
2917 // minor_version_ptr - pre-checked for null
2918 // major_version_ptr - pre-checked for null
3074 {
3075 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3076 strcpy(*source_debug_extension_ptr, sde);
3077 }
3078 }
3079
3080 return JVMTI_ERROR_NONE;
3081 } /* end GetSourceDebugExtension */
3082
3083 //
3084 // Object functions
3085 //
3086
3087 // hash_code_ptr - pre-checked for null
3088 jvmtiError
3089 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3090 oop mirror = JNIHandles::resolve_external_guard(object);
3091 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3092 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3093
3094 if (mirror->is_inline_type()) {
3095 // For inline types, use the klass as a hash code.
3096 // TBD to improve this (see also JvmtiTagMapKey::get_hash for similar case).
3097 *hash_code_ptr = (jint)((int64_t)mirror->klass() >> 3);
3098 } else {
3099 *hash_code_ptr = (jint)mirror->identity_hash();
3100 }
3101 return JVMTI_ERROR_NONE;
3102 } /* end GetObjectHashCode */
3103
3104
3105 // info_ptr - pre-checked for null
3106 jvmtiError
3107 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) {
3108 // This needs to be performed at a safepoint to gather stable data
3109 // because monitor owner / waiters might not be suspended.
3110 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr);
3111 VMThread::execute(&op);
3112 return op.result();
3113 } /* end GetObjectMonitorUsage */
3114
3115
3116 //
3117 // Field functions
3118 //
3119
|