< prev index next >

src/hotspot/share/prims/jvmtiEnv.cpp

Print this page

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

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




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