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