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