< prev index next >

src/hotspot/share/prims/jvmtiEnv.cpp

Print this page

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 
< prev index next >