< prev index next >

src/hotspot/share/prims/jvmtiEnv.cpp

Print this page

2701 
2702   Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2703   NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2704   {
2705     JavaThread* current_thread  = JavaThread::current();
2706     ResourceMark rm(current_thread);
2707     const char* sfncp = (const char*) sfnOop->as_C_string();
2708     *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2709     strcpy(*source_name_ptr, sfncp);
2710   }
2711 
2712   return JVMTI_ERROR_NONE;
2713 } /* end GetSourceFileName */
2714 
2715 
2716 // k_mirror - may be primitive, this must be checked
2717 // modifiers_ptr - pre-checked for null
2718 jvmtiError
2719 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2720   jint result = java_lang_Class::modifiers(k_mirror);
2721   if (!java_lang_Class::is_primitive(k_mirror)) {
2722     // Reset the deleted  ACC_SUPER bit (deleted in compute_modifier_flags()).
2723     result |= JVM_ACC_SUPER;
2724   }
2725   *modifiers_ptr = result;
2726 
2727   return JVMTI_ERROR_NONE;
2728 } /* end GetClassModifiers */
2729 
2730 
2731 // k_mirror - may be primitive, this must be checked
2732 // method_count_ptr - pre-checked for null
2733 // methods_ptr - pre-checked for null
2734 jvmtiError
2735 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2736   JavaThread* current_thread  = JavaThread::current();
2737   HandleMark hm(current_thread);
2738 
2739   if (java_lang_Class::is_primitive(k_mirror)) {
2740     *method_count_ptr = 0;
2741     *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2742     return JVMTI_ERROR_NONE;
2743   }
2744   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   FilteredJavaFieldStream flds(ik);
2845 
2846   int result_count = flds.field_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 

2701 
2702   Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2703   NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2704   {
2705     JavaThread* current_thread  = JavaThread::current();
2706     ResourceMark rm(current_thread);
2707     const char* sfncp = (const char*) sfnOop->as_C_string();
2708     *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2709     strcpy(*source_name_ptr, sfncp);
2710   }
2711 
2712   return JVMTI_ERROR_NONE;
2713 } /* end GetSourceFileName */
2714 
2715 
2716 // k_mirror - may be primitive, this must be checked
2717 // modifiers_ptr - pre-checked for null
2718 jvmtiError
2719 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2720   jint result = java_lang_Class::modifiers(k_mirror);




2721   *modifiers_ptr = result;
2722 
2723   return JVMTI_ERROR_NONE;
2724 } /* end GetClassModifiers */
2725 
2726 
2727 // k_mirror - may be primitive, this must be checked
2728 // method_count_ptr - pre-checked for null
2729 // methods_ptr - pre-checked for null
2730 jvmtiError
2731 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2732   JavaThread* current_thread  = JavaThread::current();
2733   HandleMark hm(current_thread);
2734 
2735   if (java_lang_Class::is_primitive(k_mirror)) {
2736     *method_count_ptr = 0;
2737     *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2738     return JVMTI_ERROR_NONE;
2739   }
2740   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   FilteredJavaFieldStream flds(ik);
2841 
2842   int result_count = flds.field_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 
< prev index next >