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