< prev index next >

src/hotspot/share/prims/jvmtiEnv.cpp

Print this page

2710 
2711   Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2712   NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2713   {
2714     JavaThread* current_thread  = JavaThread::current();
2715     ResourceMark rm(current_thread);
2716     const char* sfncp = (const char*) sfnOop->as_C_string();
2717     *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2718     strcpy(*source_name_ptr, sfncp);
2719   }
2720 
2721   return JVMTI_ERROR_NONE;
2722 } /* end GetSourceFileName */
2723 
2724 
2725 // k_mirror - may be primitive, this must be checked
2726 // modifiers_ptr - pre-checked for null
2727 jvmtiError
2728 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2729   jint result = java_lang_Class::modifiers(k_mirror);
2730   if (!java_lang_Class::is_primitive(k_mirror)) {
2731     // Reset the deleted  ACC_SUPER bit (deleted in compute_modifier_flags()).
2732     result |= JVM_ACC_SUPER;
2733   }
2734   *modifiers_ptr = result;
2735 
2736   return JVMTI_ERROR_NONE;
2737 } /* end GetClassModifiers */
2738 
2739 
2740 // k_mirror - may be primitive, this must be checked
2741 // method_count_ptr - pre-checked for null
2742 // methods_ptr - pre-checked for null
2743 jvmtiError
2744 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2745   JavaThread* current_thread  = JavaThread::current();
2746   HandleMark hm(current_thread);
2747 
2748   if (java_lang_Class::is_primitive(k_mirror)) {
2749     *method_count_ptr = 0;
2750     *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2751     return JVMTI_ERROR_NONE;
2752   }
2753   Klass* k = java_lang_Class::as_Klass(k_mirror);

2831   if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2832     return JVMTI_ERROR_CLASS_NOT_PREPARED;
2833   }
2834 
2835   if (!k->is_instance_klass()) {
2836     *field_count_ptr = 0;
2837     *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2838     return JVMTI_ERROR_NONE;
2839   }
2840 
2841   InstanceKlass* ik = InstanceKlass::cast(k);
2842 
2843   FilteredJavaFieldStream flds(ik);
2844 
2845   int result_count = flds.field_count();
2846 
2847   // Allocate the result and fill it in.
2848   jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2849   for (int i = 0; i < result_count; i++, flds.next()) {
2850     result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2851                                                      flds.access_flags().is_static());

2852   }
2853   assert(flds.done(), "just checking");
2854 
2855   // Fill in the results
2856   *field_count_ptr = result_count;
2857   *fields_ptr = result_list;
2858 
2859   return JVMTI_ERROR_NONE;
2860 } /* end GetClassFields */
2861 
2862 
2863 // k_mirror - may be primitive, this must be checked
2864 // interface_count_ptr - pre-checked for null
2865 // interfaces_ptr - pre-checked for null
2866 jvmtiError
2867 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2868   {
2869     if (java_lang_Class::is_primitive(k_mirror)) {
2870       *interface_count_ptr = 0;
2871       *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2872       return JVMTI_ERROR_NONE;
2873     }
2874     JavaThread* current_thread = JavaThread::current();
2875     HandleMark hm(current_thread);
2876     Klass* k = java_lang_Class::as_Klass(k_mirror);
2877     NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2878 
2879     // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2880     if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2881       return JVMTI_ERROR_CLASS_NOT_PREPARED;
2882 
2883     if (!k->is_instance_klass()) {
2884       *interface_count_ptr = 0;
2885       *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2886       return JVMTI_ERROR_NONE;
2887     }
2888 
2889     Array<InstanceKlass*>* interface_list = InstanceKlass::cast(k)->local_interfaces();
2890     const 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   {
3087     jint result = (jint) mirror->identity_hash();
3088     *hash_code_ptr = result;



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 

2710 
2711   Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name();
2712   NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION);
2713   {
2714     JavaThread* current_thread  = JavaThread::current();
2715     ResourceMark rm(current_thread);
2716     const char* sfncp = (const char*) sfnOop->as_C_string();
2717     *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1);
2718     strcpy(*source_name_ptr, sfncp);
2719   }
2720 
2721   return JVMTI_ERROR_NONE;
2722 } /* end GetSourceFileName */
2723 
2724 
2725 // k_mirror - may be primitive, this must be checked
2726 // modifiers_ptr - pre-checked for null
2727 jvmtiError
2728 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) {
2729   jint result = java_lang_Class::modifiers(k_mirror);




2730   *modifiers_ptr = result;
2731 
2732   return JVMTI_ERROR_NONE;
2733 } /* end GetClassModifiers */
2734 
2735 
2736 // k_mirror - may be primitive, this must be checked
2737 // method_count_ptr - pre-checked for null
2738 // methods_ptr - pre-checked for null
2739 jvmtiError
2740 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) {
2741   JavaThread* current_thread  = JavaThread::current();
2742   HandleMark hm(current_thread);
2743 
2744   if (java_lang_Class::is_primitive(k_mirror)) {
2745     *method_count_ptr = 0;
2746     *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID));
2747     return JVMTI_ERROR_NONE;
2748   }
2749   Klass* k = java_lang_Class::as_Klass(k_mirror);

2827   if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) {
2828     return JVMTI_ERROR_CLASS_NOT_PREPARED;
2829   }
2830 
2831   if (!k->is_instance_klass()) {
2832     *field_count_ptr = 0;
2833     *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID));
2834     return JVMTI_ERROR_NONE;
2835   }
2836 
2837   InstanceKlass* ik = InstanceKlass::cast(k);
2838 
2839   FilteredJavaFieldStream flds(ik);
2840 
2841   int result_count = flds.field_count();
2842 
2843   // Allocate the result and fill it in.
2844   jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID));
2845   for (int i = 0; i < result_count; i++, flds.next()) {
2846     result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(),
2847                                                      flds.access_flags().is_static(),
2848                                                      flds.field_descriptor().is_flat());
2849   }
2850   assert(flds.done(), "just checking");
2851 
2852   // Fill in the results
2853   *field_count_ptr = result_count;
2854   *fields_ptr = result_list;
2855 
2856   return JVMTI_ERROR_NONE;
2857 } /* end GetClassFields */
2858 
2859 
2860 // k_mirror - may be primitive, this must be checked
2861 // interface_count_ptr - pre-checked for null
2862 // interfaces_ptr - pre-checked for null
2863 jvmtiError
2864 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) {
2865   {
2866     if (java_lang_Class::is_primitive(k_mirror)) {
2867       *interface_count_ptr = 0;
2868       *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2869       return JVMTI_ERROR_NONE;
2870     }
2871     JavaThread* current_thread = JavaThread::current();
2872     HandleMark hm(current_thread);
2873     Klass* k = java_lang_Class::as_Klass(k_mirror);
2874     NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS);
2875 
2876     // Return CLASS_NOT_PREPARED error as per JVMTI spec.
2877     if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) ))
2878       return JVMTI_ERROR_CLASS_NOT_PREPARED;
2879 
2880     if (!k->is_instance_klass()) {
2881       *interface_count_ptr = 0;
2882       *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass));
2883       return JVMTI_ERROR_NONE;
2884     }
2885 
2886     InstanceKlass* ik = InstanceKlass::cast(k);
2887     Array<InstanceKlass*>* interface_list = ik->local_interfaces();
2888     int result_length = (interface_list == nullptr ? 0 : interface_list->length());
2889     jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass));
2890     for (int i_index = 0; i_index < result_length; i_index += 1) {
2891       InstanceKlass* klass_at = interface_list->at(i_index);
2892       assert(klass_at->is_klass(), "interfaces must be Klass*s");
2893       assert(klass_at->is_interface(), "interfaces must be interfaces");
2894       oop mirror_at = klass_at->java_mirror();
2895       Handle handle_at = Handle(current_thread, mirror_at);
2896       result_list[i_index] = (jclass) jni_reference(handle_at);
2897     }
2898     *interface_count_ptr = result_length;
2899     *interfaces_ptr = result_list;
2900   }
2901 
2902   return JVMTI_ERROR_NONE;
2903 } /* end GetImplementedInterfaces */
2904 
2905 
2906 // k_mirror - may be primitive, this must be checked
2907 // minor_version_ptr - pre-checked for null
2908 // major_version_ptr - pre-checked for null

3064     {
3065       *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1);
3066       strcpy(*source_debug_extension_ptr, sde);
3067     }
3068   }
3069 
3070   return JVMTI_ERROR_NONE;
3071 } /* end GetSourceDebugExtension */
3072 
3073   //
3074   // Object functions
3075   //
3076 
3077 // hash_code_ptr - pre-checked for null
3078 jvmtiError
3079 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) {
3080   oop mirror = JNIHandles::resolve_external_guard(object);
3081   NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);
3082   NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER);
3083 
3084   if (mirror->is_inline_type()) {
3085     // For inline types, use the klass as a hash code.
3086     // TBD to improve this (see also JvmtiTagMapKey::get_hash for similar case).
3087     *hash_code_ptr = (jint)((int64_t)mirror->klass() >> 3);
3088   } else {
3089     *hash_code_ptr = (jint)mirror->identity_hash();
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 
< prev index next >