Mercurial > hg > truffle
comparison src/share/vm/prims/jvmtiEnv.cpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 04ade88d9712 |
children | 18fb7da42534 |
comparison
equal
deleted
inserted
replaced
6724:36d1d483d5d6 | 6725:da91efe96a93 |
---|---|
28 #include "interpreter/bytecodeStream.hpp" | 28 #include "interpreter/bytecodeStream.hpp" |
29 #include "interpreter/interpreter.hpp" | 29 #include "interpreter/interpreter.hpp" |
30 #include "jvmtifiles/jvmtiEnv.hpp" | 30 #include "jvmtifiles/jvmtiEnv.hpp" |
31 #include "memory/resourceArea.hpp" | 31 #include "memory/resourceArea.hpp" |
32 #include "memory/universe.inline.hpp" | 32 #include "memory/universe.inline.hpp" |
33 #include "oops/cpCacheOop.hpp" | |
34 #include "oops/instanceKlass.hpp" | 33 #include "oops/instanceKlass.hpp" |
35 #include "prims/jniCheck.hpp" | 34 #include "prims/jniCheck.hpp" |
36 #include "prims/jvm_misc.hpp" | 35 #include "prims/jvm_misc.hpp" |
37 #include "prims/jvmtiAgentThread.hpp" | 36 #include "prims/jvmtiAgentThread.hpp" |
38 #include "prims/jvmtiClassFileReconstituter.hpp" | 37 #include "prims/jvmtiClassFileReconstituter.hpp" |
252 | 251 |
253 if (java_lang_Class::is_primitive(k_mirror)) { | 252 if (java_lang_Class::is_primitive(k_mirror)) { |
254 return JVMTI_ERROR_UNMODIFIABLE_CLASS; | 253 return JVMTI_ERROR_UNMODIFIABLE_CLASS; |
255 } | 254 } |
256 | 255 |
257 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); | 256 Klass* k_oop = java_lang_Class::as_Klass(k_mirror); |
258 KlassHandle klass(current_thread, k_oop); | 257 KlassHandle klass(current_thread, k_oop); |
259 | 258 |
260 jint status = klass->jvmti_class_status(); | 259 jint status = klass->jvmti_class_status(); |
261 if (status & (JVMTI_CLASS_STATUS_ERROR)) { | 260 if (status & (JVMTI_CLASS_STATUS_ERROR)) { |
262 return JVMTI_ERROR_INVALID_CLASS; | 261 return JVMTI_ERROR_INVALID_CLASS; |
267 | 266 |
268 instanceKlassHandle ikh(current_thread, k_oop); | 267 instanceKlassHandle ikh(current_thread, k_oop); |
269 if (ikh->get_cached_class_file_bytes() == NULL) { | 268 if (ikh->get_cached_class_file_bytes() == NULL) { |
270 // Not cached, we need to reconstitute the class file from the | 269 // Not cached, we need to reconstitute the class file from the |
271 // VM representation. We don't attach the reconstituted class | 270 // VM representation. We don't attach the reconstituted class |
272 // bytes to the instanceKlass here because they have not been | 271 // bytes to the InstanceKlass here because they have not been |
273 // validated and we're not at a safepoint. | 272 // validated and we're not at a safepoint. |
274 constantPoolHandle constants(current_thread, ikh->constants()); | 273 constantPoolHandle constants(current_thread, ikh->constants()); |
275 ObjectLocker ol(constants, current_thread); // lock constant pool while we query it | 274 MonitorLockerEx ml(constants->lock()); // lock constant pool while we query it |
276 | 275 |
277 JvmtiClassFileReconstituter reconstituter(ikh); | 276 JvmtiClassFileReconstituter reconstituter(ikh); |
278 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { | 277 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { |
279 return reconstituter.get_error(); | 278 return reconstituter.get_error(); |
280 } | 279 } |
314 jvmtiError | 313 jvmtiError |
315 JvmtiEnv::GetObjectSize(jobject object, jlong* size_ptr) { | 314 JvmtiEnv::GetObjectSize(jobject object, jlong* size_ptr) { |
316 oop mirror = JNIHandles::resolve_external_guard(object); | 315 oop mirror = JNIHandles::resolve_external_guard(object); |
317 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); | 316 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); |
318 | 317 |
319 if (mirror->klass() == SystemDictionary::Class_klass()) { | 318 if (mirror->klass() == SystemDictionary::Class_klass() && |
320 if (!java_lang_Class::is_primitive(mirror)) { | 319 !java_lang_Class::is_primitive(mirror)) { |
321 mirror = java_lang_Class::as_klassOop(mirror); | 320 Klass* k = java_lang_Class::as_Klass(mirror); |
322 assert(mirror != NULL, "class for non-primitive mirror must exist"); | 321 assert(k != NULL, "class for non-primitive mirror must exist"); |
323 } | 322 *size_ptr = k->size() * wordSize; |
324 } | 323 } else { |
325 | 324 *size_ptr = mirror->size() * wordSize; |
326 *size_ptr = mirror->size() * wordSize; | 325 } |
327 return JVMTI_ERROR_NONE; | 326 return JVMTI_ERROR_NONE; |
328 } /* end GetObjectSize */ | 327 } /* end GetObjectSize */ |
329 | 328 |
330 // | 329 // |
331 // Method functions | 330 // Method functions |
550 vmSymbols::appendToClassPathForInstrumentation_name(), | 549 vmSymbols::appendToClassPathForInstrumentation_name(), |
551 vmSymbols::appendToClassPathForInstrumentation_signature(), | 550 vmSymbols::appendToClassPathForInstrumentation_signature(), |
552 path, | 551 path, |
553 THREAD); | 552 THREAD); |
554 if (HAS_PENDING_EXCEPTION) { | 553 if (HAS_PENDING_EXCEPTION) { |
555 Symbol* ex_name = PENDING_EXCEPTION->klass()->klass_part()->name(); | 554 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); |
556 CLEAR_PENDING_EXCEPTION; | 555 CLEAR_PENDING_EXCEPTION; |
557 | 556 |
558 if (ex_name == vmSymbols::java_lang_NoSuchMethodError()) { | 557 if (ex_name == vmSymbols::java_lang_NoSuchMethodError()) { |
559 return JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED; | 558 return JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED; |
560 } else { | 559 } else { |
1618 // callbacks - pre-checked for NULL | 1617 // callbacks - pre-checked for NULL |
1619 // user_data - NULL is a valid value, must be checked | 1618 // user_data - NULL is a valid value, must be checked |
1620 jvmtiError | 1619 jvmtiError |
1621 JvmtiEnv::FollowReferences(jint heap_filter, jclass klass, jobject initial_object, const jvmtiHeapCallbacks* callbacks, const void* user_data) { | 1620 JvmtiEnv::FollowReferences(jint heap_filter, jclass klass, jobject initial_object, const jvmtiHeapCallbacks* callbacks, const void* user_data) { |
1622 // check klass if provided | 1621 // check klass if provided |
1623 klassOop k_oop = NULL; | 1622 Klass* k_oop = NULL; |
1624 if (klass != NULL) { | 1623 if (klass != NULL) { |
1625 oop k_mirror = JNIHandles::resolve_external_guard(klass); | 1624 oop k_mirror = JNIHandles::resolve_external_guard(klass); |
1626 if (k_mirror == NULL) { | 1625 if (k_mirror == NULL) { |
1627 return JVMTI_ERROR_INVALID_CLASS; | 1626 return JVMTI_ERROR_INVALID_CLASS; |
1628 } | 1627 } |
1629 if (java_lang_Class::is_primitive(k_mirror)) { | 1628 if (java_lang_Class::is_primitive(k_mirror)) { |
1630 return JVMTI_ERROR_NONE; | 1629 return JVMTI_ERROR_NONE; |
1631 } | 1630 } |
1632 k_oop = java_lang_Class::as_klassOop(k_mirror); | 1631 k_oop = java_lang_Class::as_Klass(k_mirror); |
1633 if (k_oop == NULL) { | 1632 if (k_oop == NULL) { |
1634 return JVMTI_ERROR_INVALID_CLASS; | 1633 return JVMTI_ERROR_INVALID_CLASS; |
1635 } | 1634 } |
1636 } | 1635 } |
1637 | 1636 |
1649 // callbacks - pre-checked for NULL | 1648 // callbacks - pre-checked for NULL |
1650 // user_data - NULL is a valid value, must be checked | 1649 // user_data - NULL is a valid value, must be checked |
1651 jvmtiError | 1650 jvmtiError |
1652 JvmtiEnv::IterateThroughHeap(jint heap_filter, jclass klass, const jvmtiHeapCallbacks* callbacks, const void* user_data) { | 1651 JvmtiEnv::IterateThroughHeap(jint heap_filter, jclass klass, const jvmtiHeapCallbacks* callbacks, const void* user_data) { |
1653 // check klass if provided | 1652 // check klass if provided |
1654 klassOop k_oop = NULL; | 1653 Klass* k_oop = NULL; |
1655 if (klass != NULL) { | 1654 if (klass != NULL) { |
1656 oop k_mirror = JNIHandles::resolve_external_guard(klass); | 1655 oop k_mirror = JNIHandles::resolve_external_guard(klass); |
1657 if (k_mirror == NULL) { | 1656 if (k_mirror == NULL) { |
1658 return JVMTI_ERROR_INVALID_CLASS; | 1657 return JVMTI_ERROR_INVALID_CLASS; |
1659 } | 1658 } |
1660 if (java_lang_Class::is_primitive(k_mirror)) { | 1659 if (java_lang_Class::is_primitive(k_mirror)) { |
1661 return JVMTI_ERROR_NONE; | 1660 return JVMTI_ERROR_NONE; |
1662 } | 1661 } |
1663 k_oop = java_lang_Class::as_klassOop(k_mirror); | 1662 k_oop = java_lang_Class::as_Klass(k_mirror); |
1664 if (k_oop == NULL) { | 1663 if (k_oop == NULL) { |
1665 return JVMTI_ERROR_INVALID_CLASS; | 1664 return JVMTI_ERROR_INVALID_CLASS; |
1666 } | 1665 } |
1667 } | 1666 } |
1668 | 1667 |
1760 JvmtiEnv::IterateOverInstancesOfClass(oop k_mirror, jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void* user_data) { | 1759 JvmtiEnv::IterateOverInstancesOfClass(oop k_mirror, jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void* user_data) { |
1761 if (java_lang_Class::is_primitive(k_mirror)) { | 1760 if (java_lang_Class::is_primitive(k_mirror)) { |
1762 // DO PRIMITIVE CLASS PROCESSING | 1761 // DO PRIMITIVE CLASS PROCESSING |
1763 return JVMTI_ERROR_NONE; | 1762 return JVMTI_ERROR_NONE; |
1764 } | 1763 } |
1765 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); | 1764 Klass* k_oop = java_lang_Class::as_Klass(k_mirror); |
1766 if (k_oop == NULL) { | 1765 if (k_oop == NULL) { |
1767 return JVMTI_ERROR_INVALID_CLASS; | 1766 return JVMTI_ERROR_INVALID_CLASS; |
1768 } | 1767 } |
1769 Thread *thread = Thread::current(); | 1768 Thread *thread = Thread::current(); |
1770 HandleMark hm(thread); | 1769 HandleMark hm(thread); |
1987 // Breakpoint functions | 1986 // Breakpoint functions |
1988 // | 1987 // |
1989 | 1988 |
1990 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 1989 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
1991 jvmtiError | 1990 jvmtiError |
1992 JvmtiEnv::SetBreakpoint(methodOop method_oop, jlocation location) { | 1991 JvmtiEnv::SetBreakpoint(Method* method_oop, jlocation location) { |
1993 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 1992 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
1994 if (location < 0) { // simple invalid location check first | 1993 if (location < 0) { // simple invalid location check first |
1995 return JVMTI_ERROR_INVALID_LOCATION; | 1994 return JVMTI_ERROR_INVALID_LOCATION; |
1996 } | 1995 } |
1997 // verify that the breakpoint is not past the end of the method | 1996 // verify that the breakpoint is not past the end of the method |
2013 } /* end SetBreakpoint */ | 2012 } /* end SetBreakpoint */ |
2014 | 2013 |
2015 | 2014 |
2016 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2015 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2017 jvmtiError | 2016 jvmtiError |
2018 JvmtiEnv::ClearBreakpoint(methodOop method_oop, jlocation location) { | 2017 JvmtiEnv::ClearBreakpoint(Method* method_oop, jlocation location) { |
2019 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2018 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2020 | 2019 |
2021 if (location < 0) { // simple invalid location check first | 2020 if (location < 0) { // simple invalid location check first |
2022 return JVMTI_ERROR_INVALID_LOCATION; | 2021 return JVMTI_ERROR_INVALID_LOCATION; |
2023 } | 2022 } |
2102 // generic_ptr - NULL is a valid value, must be checked | 2101 // generic_ptr - NULL is a valid value, must be checked |
2103 jvmtiError | 2102 jvmtiError |
2104 JvmtiEnv::GetClassSignature(oop k_mirror, char** signature_ptr, char** generic_ptr) { | 2103 JvmtiEnv::GetClassSignature(oop k_mirror, char** signature_ptr, char** generic_ptr) { |
2105 ResourceMark rm; | 2104 ResourceMark rm; |
2106 bool isPrimitive = java_lang_Class::is_primitive(k_mirror); | 2105 bool isPrimitive = java_lang_Class::is_primitive(k_mirror); |
2107 klassOop k = NULL; | 2106 Klass* k = NULL; |
2108 if (!isPrimitive) { | 2107 if (!isPrimitive) { |
2109 k = java_lang_Class::as_klassOop(k_mirror); | 2108 k = java_lang_Class::as_Klass(k_mirror); |
2110 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2109 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2111 } | 2110 } |
2112 if (signature_ptr != NULL) { | 2111 if (signature_ptr != NULL) { |
2113 char* result = NULL; | 2112 char* result = NULL; |
2114 if (isPrimitive) { | 2113 if (isPrimitive) { |
2124 *signature_ptr = result; | 2123 *signature_ptr = result; |
2125 } | 2124 } |
2126 if (generic_ptr != NULL) { | 2125 if (generic_ptr != NULL) { |
2127 *generic_ptr = NULL; | 2126 *generic_ptr = NULL; |
2128 if (!isPrimitive && Klass::cast(k)->oop_is_instance()) { | 2127 if (!isPrimitive && Klass::cast(k)->oop_is_instance()) { |
2129 Symbol* soo = instanceKlass::cast(k)->generic_signature(); | 2128 Symbol* soo = InstanceKlass::cast(k)->generic_signature(); |
2130 if (soo != NULL) { | 2129 if (soo != NULL) { |
2131 const char *gen_sig = soo->as_C_string(); | 2130 const char *gen_sig = soo->as_C_string(); |
2132 if (gen_sig != NULL) { | 2131 if (gen_sig != NULL) { |
2133 char* gen_result; | 2132 char* gen_result; |
2134 jvmtiError err = allocate(strlen(gen_sig) + 1, | 2133 jvmtiError err = allocate(strlen(gen_sig) + 1, |
2152 JvmtiEnv::GetClassStatus(oop k_mirror, jint* status_ptr) { | 2151 JvmtiEnv::GetClassStatus(oop k_mirror, jint* status_ptr) { |
2153 jint result = 0; | 2152 jint result = 0; |
2154 if (java_lang_Class::is_primitive(k_mirror)) { | 2153 if (java_lang_Class::is_primitive(k_mirror)) { |
2155 result |= JVMTI_CLASS_STATUS_PRIMITIVE; | 2154 result |= JVMTI_CLASS_STATUS_PRIMITIVE; |
2156 } else { | 2155 } else { |
2157 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2156 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2158 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2157 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2159 result = Klass::cast(k)->jvmti_class_status(); | 2158 result = Klass::cast(k)->jvmti_class_status(); |
2160 } | 2159 } |
2161 *status_ptr = result; | 2160 *status_ptr = result; |
2162 | 2161 |
2169 jvmtiError | 2168 jvmtiError |
2170 JvmtiEnv::GetSourceFileName(oop k_mirror, char** source_name_ptr) { | 2169 JvmtiEnv::GetSourceFileName(oop k_mirror, char** source_name_ptr) { |
2171 if (java_lang_Class::is_primitive(k_mirror)) { | 2170 if (java_lang_Class::is_primitive(k_mirror)) { |
2172 return JVMTI_ERROR_ABSENT_INFORMATION; | 2171 return JVMTI_ERROR_ABSENT_INFORMATION; |
2173 } | 2172 } |
2174 klassOop k_klass = java_lang_Class::as_klassOop(k_mirror); | 2173 Klass* k_klass = java_lang_Class::as_Klass(k_mirror); |
2175 NULL_CHECK(k_klass, JVMTI_ERROR_INVALID_CLASS); | 2174 NULL_CHECK(k_klass, JVMTI_ERROR_INVALID_CLASS); |
2176 | 2175 |
2177 if (!Klass::cast(k_klass)->oop_is_instance()) { | 2176 if (!Klass::cast(k_klass)->oop_is_instance()) { |
2178 return JVMTI_ERROR_ABSENT_INFORMATION; | 2177 return JVMTI_ERROR_ABSENT_INFORMATION; |
2179 } | 2178 } |
2180 | 2179 |
2181 Symbol* sfnOop = instanceKlass::cast(k_klass)->source_file_name(); | 2180 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name(); |
2182 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION); | 2181 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION); |
2183 { | 2182 { |
2184 JavaThread* current_thread = JavaThread::current(); | 2183 JavaThread* current_thread = JavaThread::current(); |
2185 ResourceMark rm(current_thread); | 2184 ResourceMark rm(current_thread); |
2186 const char* sfncp = (const char*) sfnOop->as_C_string(); | 2185 const char* sfncp = (const char*) sfnOop->as_C_string(); |
2197 jvmtiError | 2196 jvmtiError |
2198 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) { | 2197 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) { |
2199 JavaThread* current_thread = JavaThread::current(); | 2198 JavaThread* current_thread = JavaThread::current(); |
2200 jint result = 0; | 2199 jint result = 0; |
2201 if (!java_lang_Class::is_primitive(k_mirror)) { | 2200 if (!java_lang_Class::is_primitive(k_mirror)) { |
2202 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2201 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2203 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2202 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2204 assert((Klass::cast(k)->oop_is_instance() || Klass::cast(k)->oop_is_array()), "should be an instance or an array klass"); | |
2205 result = Klass::cast(k)->compute_modifier_flags(current_thread); | 2203 result = Klass::cast(k)->compute_modifier_flags(current_thread); |
2206 JavaThread* THREAD = current_thread; // pass to macros | 2204 JavaThread* THREAD = current_thread; // pass to macros |
2207 if (HAS_PENDING_EXCEPTION) { | 2205 if (HAS_PENDING_EXCEPTION) { |
2208 CLEAR_PENDING_EXCEPTION; | 2206 CLEAR_PENDING_EXCEPTION; |
2209 return JVMTI_ERROR_INTERNAL; | 2207 return JVMTI_ERROR_INTERNAL; |
2233 if (java_lang_Class::is_primitive(k_mirror)) { | 2231 if (java_lang_Class::is_primitive(k_mirror)) { |
2234 *method_count_ptr = 0; | 2232 *method_count_ptr = 0; |
2235 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID)); | 2233 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID)); |
2236 return JVMTI_ERROR_NONE; | 2234 return JVMTI_ERROR_NONE; |
2237 } | 2235 } |
2238 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2236 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2239 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2237 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2240 | 2238 |
2241 // Return CLASS_NOT_PREPARED error as per JVMTI spec. | 2239 // Return CLASS_NOT_PREPARED error as per JVMTI spec. |
2242 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { | 2240 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { |
2243 return JVMTI_ERROR_CLASS_NOT_PREPARED; | 2241 return JVMTI_ERROR_CLASS_NOT_PREPARED; |
2255 int index; | 2253 int index; |
2256 if (JvmtiExport::can_maintain_original_method_order()) { | 2254 if (JvmtiExport::can_maintain_original_method_order()) { |
2257 // Use the original method ordering indices stored in the class, so we can emit | 2255 // Use the original method ordering indices stored in the class, so we can emit |
2258 // jmethodIDs in the order they appeared in the class file | 2256 // jmethodIDs in the order they appeared in the class file |
2259 for (index = 0; index < result_length; index++) { | 2257 for (index = 0; index < result_length; index++) { |
2260 methodOop m = methodOop(instanceK_h->methods()->obj_at(index)); | 2258 Method* m = instanceK_h->methods()->at(index); |
2261 int original_index = instanceK_h->method_ordering()->int_at(index); | 2259 int original_index = instanceK_h->method_ordering()->at(index); |
2262 assert(original_index >= 0 && original_index < result_length, "invalid original method index"); | 2260 assert(original_index >= 0 && original_index < result_length, "invalid original method index"); |
2263 jmethodID id = m->jmethod_id(); | 2261 jmethodID id = m->jmethod_id(); |
2264 result_list[original_index] = id; | 2262 result_list[original_index] = id; |
2265 } | 2263 } |
2266 } else { | 2264 } else { |
2267 // otherwise just copy in any order | 2265 // otherwise just copy in any order |
2268 for (index = 0; index < result_length; index++) { | 2266 for (index = 0; index < result_length; index++) { |
2269 methodOop m = methodOop(instanceK_h->methods()->obj_at(index)); | 2267 Method* m = instanceK_h->methods()->at(index); |
2270 jmethodID id = m->jmethod_id(); | 2268 jmethodID id = m->jmethod_id(); |
2271 result_list[index] = id; | 2269 result_list[index] = id; |
2272 } | 2270 } |
2273 } | 2271 } |
2274 // Fill in return value. | 2272 // Fill in return value. |
2289 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID)); | 2287 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID)); |
2290 return JVMTI_ERROR_NONE; | 2288 return JVMTI_ERROR_NONE; |
2291 } | 2289 } |
2292 JavaThread* current_thread = JavaThread::current(); | 2290 JavaThread* current_thread = JavaThread::current(); |
2293 HandleMark hm(current_thread); | 2291 HandleMark hm(current_thread); |
2294 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2292 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2295 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2293 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2296 | 2294 |
2297 // Return CLASS_NOT_PREPARED error as per JVMTI spec. | 2295 // Return CLASS_NOT_PREPARED error as per JVMTI spec. |
2298 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { | 2296 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { |
2299 return JVMTI_ERROR_CLASS_NOT_PREPARED; | 2297 return JVMTI_ERROR_CLASS_NOT_PREPARED; |
2344 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); | 2342 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); |
2345 return JVMTI_ERROR_NONE; | 2343 return JVMTI_ERROR_NONE; |
2346 } | 2344 } |
2347 JavaThread* current_thread = JavaThread::current(); | 2345 JavaThread* current_thread = JavaThread::current(); |
2348 HandleMark hm(current_thread); | 2346 HandleMark hm(current_thread); |
2349 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2347 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2350 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2348 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2351 | 2349 |
2352 // Return CLASS_NOT_PREPARED error as per JVMTI spec. | 2350 // Return CLASS_NOT_PREPARED error as per JVMTI spec. |
2353 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) | 2351 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) |
2354 return JVMTI_ERROR_CLASS_NOT_PREPARED; | 2352 return JVMTI_ERROR_CLASS_NOT_PREPARED; |
2357 *interface_count_ptr = 0; | 2355 *interface_count_ptr = 0; |
2358 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); | 2356 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); |
2359 return JVMTI_ERROR_NONE; | 2357 return JVMTI_ERROR_NONE; |
2360 } | 2358 } |
2361 | 2359 |
2362 objArrayHandle interface_list(current_thread, instanceKlass::cast(k)->local_interfaces()); | 2360 Array<Klass*>* interface_list = InstanceKlass::cast(k)->local_interfaces(); |
2363 const int result_length = (interface_list.is_null() ? 0 : interface_list->length()); | 2361 const int result_length = (interface_list == NULL ? 0 : interface_list->length()); |
2364 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass)); | 2362 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass)); |
2365 for (int i_index = 0; i_index < result_length; i_index += 1) { | 2363 for (int i_index = 0; i_index < result_length; i_index += 1) { |
2366 oop oop_at = interface_list->obj_at(i_index); | 2364 Klass* klass_at = interface_list->at(i_index); |
2367 assert(oop_at->is_klass(), "interfaces must be klassOops"); | 2365 assert(klass_at->is_klass(), "interfaces must be Klass*s"); |
2368 klassOop klassOop_at = klassOop(oop_at); // ???: is there a better way? | 2366 assert(Klass::cast(klass_at)->is_interface(), "interfaces must be interfaces"); |
2369 assert(Klass::cast(klassOop_at)->is_interface(), "interfaces must be interfaces"); | 2367 oop mirror_at = Klass::cast(klass_at)->java_mirror(); |
2370 oop mirror_at = Klass::cast(klassOop_at)->java_mirror(); | |
2371 Handle handle_at = Handle(current_thread, mirror_at); | 2368 Handle handle_at = Handle(current_thread, mirror_at); |
2372 result_list[i_index] = (jclass) jni_reference(handle_at); | 2369 result_list[i_index] = (jclass) jni_reference(handle_at); |
2373 } | 2370 } |
2374 *interface_count_ptr = result_length; | 2371 *interface_count_ptr = result_length; |
2375 *interfaces_ptr = result_list; | 2372 *interfaces_ptr = result_list; |
2385 jvmtiError | 2382 jvmtiError |
2386 JvmtiEnv::GetClassVersionNumbers(oop k_mirror, jint* minor_version_ptr, jint* major_version_ptr) { | 2383 JvmtiEnv::GetClassVersionNumbers(oop k_mirror, jint* minor_version_ptr, jint* major_version_ptr) { |
2387 if (java_lang_Class::is_primitive(k_mirror)) { | 2384 if (java_lang_Class::is_primitive(k_mirror)) { |
2388 return JVMTI_ERROR_ABSENT_INFORMATION; | 2385 return JVMTI_ERROR_ABSENT_INFORMATION; |
2389 } | 2386 } |
2390 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); | 2387 Klass* k_oop = java_lang_Class::as_Klass(k_mirror); |
2391 Thread *thread = Thread::current(); | 2388 Thread *thread = Thread::current(); |
2392 HandleMark hm(thread); | 2389 HandleMark hm(thread); |
2393 KlassHandle klass(thread, k_oop); | 2390 KlassHandle klass(thread, k_oop); |
2394 | 2391 |
2395 jint status = klass->jvmti_class_status(); | 2392 jint status = klass->jvmti_class_status(); |
2416 JvmtiEnv::GetConstantPool(oop k_mirror, jint* constant_pool_count_ptr, jint* constant_pool_byte_count_ptr, unsigned char** constant_pool_bytes_ptr) { | 2413 JvmtiEnv::GetConstantPool(oop k_mirror, jint* constant_pool_count_ptr, jint* constant_pool_byte_count_ptr, unsigned char** constant_pool_bytes_ptr) { |
2417 if (java_lang_Class::is_primitive(k_mirror)) { | 2414 if (java_lang_Class::is_primitive(k_mirror)) { |
2418 return JVMTI_ERROR_ABSENT_INFORMATION; | 2415 return JVMTI_ERROR_ABSENT_INFORMATION; |
2419 } | 2416 } |
2420 | 2417 |
2421 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); | 2418 Klass* k_oop = java_lang_Class::as_Klass(k_mirror); |
2422 Thread *thread = Thread::current(); | 2419 Thread *thread = Thread::current(); |
2423 HandleMark hm(thread); | 2420 HandleMark hm(thread); |
2424 ResourceMark rm(thread); | 2421 ResourceMark rm(thread); |
2425 KlassHandle klass(thread, k_oop); | 2422 KlassHandle klass(thread, k_oop); |
2426 | 2423 |
2432 return JVMTI_ERROR_ABSENT_INFORMATION; | 2429 return JVMTI_ERROR_ABSENT_INFORMATION; |
2433 } | 2430 } |
2434 | 2431 |
2435 instanceKlassHandle ikh(thread, k_oop); | 2432 instanceKlassHandle ikh(thread, k_oop); |
2436 constantPoolHandle constants(thread, ikh->constants()); | 2433 constantPoolHandle constants(thread, ikh->constants()); |
2437 ObjectLocker ol(constants, thread); // lock constant pool while we query it | 2434 MonitorLockerEx ml(constants->lock()); // lock constant pool while we query it |
2438 | 2435 |
2439 JvmtiConstantPoolReconstituter reconstituter(ikh); | 2436 JvmtiConstantPoolReconstituter reconstituter(ikh); |
2440 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { | 2437 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { |
2441 return reconstituter.get_error(); | 2438 return reconstituter.get_error(); |
2442 } | 2439 } |
2468 jvmtiError | 2465 jvmtiError |
2469 JvmtiEnv::IsInterface(oop k_mirror, jboolean* is_interface_ptr) { | 2466 JvmtiEnv::IsInterface(oop k_mirror, jboolean* is_interface_ptr) { |
2470 { | 2467 { |
2471 bool result = false; | 2468 bool result = false; |
2472 if (!java_lang_Class::is_primitive(k_mirror)) { | 2469 if (!java_lang_Class::is_primitive(k_mirror)) { |
2473 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2470 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2474 if (k != NULL && Klass::cast(k)->is_interface()) { | 2471 if (k != NULL && Klass::cast(k)->is_interface()) { |
2475 result = true; | 2472 result = true; |
2476 } | 2473 } |
2477 } | 2474 } |
2478 *is_interface_ptr = result; | 2475 *is_interface_ptr = result; |
2487 jvmtiError | 2484 jvmtiError |
2488 JvmtiEnv::IsArrayClass(oop k_mirror, jboolean* is_array_class_ptr) { | 2485 JvmtiEnv::IsArrayClass(oop k_mirror, jboolean* is_array_class_ptr) { |
2489 { | 2486 { |
2490 bool result = false; | 2487 bool result = false; |
2491 if (!java_lang_Class::is_primitive(k_mirror)) { | 2488 if (!java_lang_Class::is_primitive(k_mirror)) { |
2492 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2489 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2493 if (k != NULL && Klass::cast(k)->oop_is_array()) { | 2490 if (k != NULL && Klass::cast(k)->oop_is_array()) { |
2494 result = true; | 2491 result = true; |
2495 } | 2492 } |
2496 } | 2493 } |
2497 *is_array_class_ptr = result; | 2494 *is_array_class_ptr = result; |
2510 *classloader_ptr = (jclass) jni_reference(Handle()); | 2507 *classloader_ptr = (jclass) jni_reference(Handle()); |
2511 return JVMTI_ERROR_NONE; | 2508 return JVMTI_ERROR_NONE; |
2512 } | 2509 } |
2513 JavaThread* current_thread = JavaThread::current(); | 2510 JavaThread* current_thread = JavaThread::current(); |
2514 HandleMark hm(current_thread); | 2511 HandleMark hm(current_thread); |
2515 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2512 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2516 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2513 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2517 | 2514 |
2518 oop result_oop = Klass::cast(k)->class_loader(); | 2515 oop result_oop = Klass::cast(k)->class_loader(); |
2519 if (result_oop == NULL) { | 2516 if (result_oop == NULL) { |
2520 *classloader_ptr = (jclass) jni_reference(Handle()); | 2517 *classloader_ptr = (jclass) jni_reference(Handle()); |
2534 JvmtiEnv::GetSourceDebugExtension(oop k_mirror, char** source_debug_extension_ptr) { | 2531 JvmtiEnv::GetSourceDebugExtension(oop k_mirror, char** source_debug_extension_ptr) { |
2535 { | 2532 { |
2536 if (java_lang_Class::is_primitive(k_mirror)) { | 2533 if (java_lang_Class::is_primitive(k_mirror)) { |
2537 return JVMTI_ERROR_ABSENT_INFORMATION; | 2534 return JVMTI_ERROR_ABSENT_INFORMATION; |
2538 } | 2535 } |
2539 klassOop k = java_lang_Class::as_klassOop(k_mirror); | 2536 Klass* k = java_lang_Class::as_Klass(k_mirror); |
2540 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); | 2537 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); |
2541 if (!Klass::cast(k)->oop_is_instance()) { | 2538 if (!Klass::cast(k)->oop_is_instance()) { |
2542 return JVMTI_ERROR_ABSENT_INFORMATION; | 2539 return JVMTI_ERROR_ABSENT_INFORMATION; |
2543 } | 2540 } |
2544 char* sde = instanceKlass::cast(k)->source_debug_extension(); | 2541 char* sde = InstanceKlass::cast(k)->source_debug_extension(); |
2545 NULL_CHECK(sde, JVMTI_ERROR_ABSENT_INFORMATION); | 2542 NULL_CHECK(sde, JVMTI_ERROR_ABSENT_INFORMATION); |
2546 | 2543 |
2547 { | 2544 { |
2548 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1); | 2545 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1); |
2549 strcpy(*source_debug_extension_ptr, sde); | 2546 strcpy(*source_debug_extension_ptr, sde); |
2670 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2667 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2671 // name_ptr - NULL is a valid value, must be checked | 2668 // name_ptr - NULL is a valid value, must be checked |
2672 // signature_ptr - NULL is a valid value, must be checked | 2669 // signature_ptr - NULL is a valid value, must be checked |
2673 // generic_ptr - NULL is a valid value, must be checked | 2670 // generic_ptr - NULL is a valid value, must be checked |
2674 jvmtiError | 2671 jvmtiError |
2675 JvmtiEnv::GetMethodName(methodOop method_oop, char** name_ptr, char** signature_ptr, char** generic_ptr) { | 2672 JvmtiEnv::GetMethodName(Method* method_oop, char** name_ptr, char** signature_ptr, char** generic_ptr) { |
2676 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2673 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2677 JavaThread* current_thread = JavaThread::current(); | 2674 JavaThread* current_thread = JavaThread::current(); |
2678 | 2675 |
2679 ResourceMark rm(current_thread); // get the utf8 name and signature | 2676 ResourceMark rm(current_thread); // get the utf8 name and signature |
2680 if (name_ptr == NULL) { | 2677 if (name_ptr == NULL) { |
2711 | 2708 |
2712 | 2709 |
2713 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2710 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2714 // declaring_class_ptr - pre-checked for NULL | 2711 // declaring_class_ptr - pre-checked for NULL |
2715 jvmtiError | 2712 jvmtiError |
2716 JvmtiEnv::GetMethodDeclaringClass(methodOop method_oop, jclass* declaring_class_ptr) { | 2713 JvmtiEnv::GetMethodDeclaringClass(Method* method_oop, jclass* declaring_class_ptr) { |
2717 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2714 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2718 (*declaring_class_ptr) = get_jni_class_non_null(method_oop->method_holder()); | 2715 (*declaring_class_ptr) = get_jni_class_non_null(method_oop->method_holder()); |
2719 return JVMTI_ERROR_NONE; | 2716 return JVMTI_ERROR_NONE; |
2720 } /* end GetMethodDeclaringClass */ | 2717 } /* end GetMethodDeclaringClass */ |
2721 | 2718 |
2722 | 2719 |
2723 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2720 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2724 // modifiers_ptr - pre-checked for NULL | 2721 // modifiers_ptr - pre-checked for NULL |
2725 jvmtiError | 2722 jvmtiError |
2726 JvmtiEnv::GetMethodModifiers(methodOop method_oop, jint* modifiers_ptr) { | 2723 JvmtiEnv::GetMethodModifiers(Method* method_oop, jint* modifiers_ptr) { |
2727 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2724 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2728 (*modifiers_ptr) = method_oop->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; | 2725 (*modifiers_ptr) = method_oop->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; |
2729 return JVMTI_ERROR_NONE; | 2726 return JVMTI_ERROR_NONE; |
2730 } /* end GetMethodModifiers */ | 2727 } /* end GetMethodModifiers */ |
2731 | 2728 |
2732 | 2729 |
2733 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2730 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2734 // max_ptr - pre-checked for NULL | 2731 // max_ptr - pre-checked for NULL |
2735 jvmtiError | 2732 jvmtiError |
2736 JvmtiEnv::GetMaxLocals(methodOop method_oop, jint* max_ptr) { | 2733 JvmtiEnv::GetMaxLocals(Method* method_oop, jint* max_ptr) { |
2737 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2734 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2738 // get max stack | 2735 // get max stack |
2739 (*max_ptr) = method_oop->max_locals(); | 2736 (*max_ptr) = method_oop->max_locals(); |
2740 return JVMTI_ERROR_NONE; | 2737 return JVMTI_ERROR_NONE; |
2741 } /* end GetMaxLocals */ | 2738 } /* end GetMaxLocals */ |
2742 | 2739 |
2743 | 2740 |
2744 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2741 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2745 // size_ptr - pre-checked for NULL | 2742 // size_ptr - pre-checked for NULL |
2746 jvmtiError | 2743 jvmtiError |
2747 JvmtiEnv::GetArgumentsSize(methodOop method_oop, jint* size_ptr) { | 2744 JvmtiEnv::GetArgumentsSize(Method* method_oop, jint* size_ptr) { |
2748 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2745 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2749 // get size of arguments | 2746 // get size of arguments |
2750 | 2747 |
2751 (*size_ptr) = method_oop->size_of_parameters(); | 2748 (*size_ptr) = method_oop->size_of_parameters(); |
2752 return JVMTI_ERROR_NONE; | 2749 return JVMTI_ERROR_NONE; |
2755 | 2752 |
2756 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2753 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2757 // entry_count_ptr - pre-checked for NULL | 2754 // entry_count_ptr - pre-checked for NULL |
2758 // table_ptr - pre-checked for NULL | 2755 // table_ptr - pre-checked for NULL |
2759 jvmtiError | 2756 jvmtiError |
2760 JvmtiEnv::GetLineNumberTable(methodOop method_oop, jint* entry_count_ptr, jvmtiLineNumberEntry** table_ptr) { | 2757 JvmtiEnv::GetLineNumberTable(Method* method_oop, jint* entry_count_ptr, jvmtiLineNumberEntry** table_ptr) { |
2761 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2758 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2762 if (!method_oop->has_linenumber_table()) { | 2759 if (!method_oop->has_linenumber_table()) { |
2763 return (JVMTI_ERROR_ABSENT_INFORMATION); | 2760 return (JVMTI_ERROR_ABSENT_INFORMATION); |
2764 } | 2761 } |
2765 | 2762 |
2797 | 2794 |
2798 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2795 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2799 // start_location_ptr - pre-checked for NULL | 2796 // start_location_ptr - pre-checked for NULL |
2800 // end_location_ptr - pre-checked for NULL | 2797 // end_location_ptr - pre-checked for NULL |
2801 jvmtiError | 2798 jvmtiError |
2802 JvmtiEnv::GetMethodLocation(methodOop method_oop, jlocation* start_location_ptr, jlocation* end_location_ptr) { | 2799 JvmtiEnv::GetMethodLocation(Method* method_oop, jlocation* start_location_ptr, jlocation* end_location_ptr) { |
2803 | 2800 |
2804 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2801 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2805 // get start and end location | 2802 // get start and end location |
2806 (*end_location_ptr) = (jlocation) (method_oop->code_size() - 1); | 2803 (*end_location_ptr) = (jlocation) (method_oop->code_size() - 1); |
2807 if (method_oop->code_size() == 0) { | 2804 if (method_oop->code_size() == 0) { |
2817 | 2814 |
2818 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2815 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2819 // entry_count_ptr - pre-checked for NULL | 2816 // entry_count_ptr - pre-checked for NULL |
2820 // table_ptr - pre-checked for NULL | 2817 // table_ptr - pre-checked for NULL |
2821 jvmtiError | 2818 jvmtiError |
2822 JvmtiEnv::GetLocalVariableTable(methodOop method_oop, jint* entry_count_ptr, jvmtiLocalVariableEntry** table_ptr) { | 2819 JvmtiEnv::GetLocalVariableTable(Method* method_oop, jint* entry_count_ptr, jvmtiLocalVariableEntry** table_ptr) { |
2823 | 2820 |
2824 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2821 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2825 JavaThread* current_thread = JavaThread::current(); | 2822 JavaThread* current_thread = JavaThread::current(); |
2826 | 2823 |
2827 // does the klass have any local variable information? | 2824 // does the klass have any local variable information? |
2828 instanceKlass* ik = instanceKlass::cast(method_oop->method_holder()); | 2825 InstanceKlass* ik = InstanceKlass::cast(method_oop->method_holder()); |
2829 if (!ik->access_flags().has_localvariable_table()) { | 2826 if (!ik->access_flags().has_localvariable_table()) { |
2830 return (JVMTI_ERROR_ABSENT_INFORMATION); | 2827 return (JVMTI_ERROR_ABSENT_INFORMATION); |
2831 } | 2828 } |
2832 | 2829 |
2833 constantPoolOop constants = method_oop->constants(); | 2830 ConstantPool* constants = method_oop->constants(); |
2834 NULL_CHECK(constants, JVMTI_ERROR_ABSENT_INFORMATION); | 2831 NULL_CHECK(constants, JVMTI_ERROR_ABSENT_INFORMATION); |
2835 | 2832 |
2836 // in the vm localvariable table representation, 6 consecutive elements in the table | 2833 // in the vm localvariable table representation, 6 consecutive elements in the table |
2837 // represent a 6-tuple of shorts | 2834 // represent a 6-tuple of shorts |
2838 // [start_pc, length, name_index, descriptor_index, signature_index, index] | 2835 // [start_pc, length, name_index, descriptor_index, signature_index, index] |
2894 | 2891 |
2895 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2892 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2896 // bytecode_count_ptr - pre-checked for NULL | 2893 // bytecode_count_ptr - pre-checked for NULL |
2897 // bytecodes_ptr - pre-checked for NULL | 2894 // bytecodes_ptr - pre-checked for NULL |
2898 jvmtiError | 2895 jvmtiError |
2899 JvmtiEnv::GetBytecodes(methodOop method_oop, jint* bytecode_count_ptr, unsigned char** bytecodes_ptr) { | 2896 JvmtiEnv::GetBytecodes(Method* method_oop, jint* bytecode_count_ptr, unsigned char** bytecodes_ptr) { |
2900 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2897 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2901 | 2898 |
2902 HandleMark hm; | 2899 HandleMark hm; |
2903 methodHandle method(method_oop); | 2900 methodHandle method(method_oop); |
2904 jint size = (jint)method->code_size(); | 2901 jint size = (jint)method->code_size(); |
2916 | 2913 |
2917 | 2914 |
2918 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2915 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2919 // is_native_ptr - pre-checked for NULL | 2916 // is_native_ptr - pre-checked for NULL |
2920 jvmtiError | 2917 jvmtiError |
2921 JvmtiEnv::IsMethodNative(methodOop method_oop, jboolean* is_native_ptr) { | 2918 JvmtiEnv::IsMethodNative(Method* method_oop, jboolean* is_native_ptr) { |
2922 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2919 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2923 (*is_native_ptr) = method_oop->is_native(); | 2920 (*is_native_ptr) = method_oop->is_native(); |
2924 return JVMTI_ERROR_NONE; | 2921 return JVMTI_ERROR_NONE; |
2925 } /* end IsMethodNative */ | 2922 } /* end IsMethodNative */ |
2926 | 2923 |
2927 | 2924 |
2928 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2925 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2929 // is_synthetic_ptr - pre-checked for NULL | 2926 // is_synthetic_ptr - pre-checked for NULL |
2930 jvmtiError | 2927 jvmtiError |
2931 JvmtiEnv::IsMethodSynthetic(methodOop method_oop, jboolean* is_synthetic_ptr) { | 2928 JvmtiEnv::IsMethodSynthetic(Method* method_oop, jboolean* is_synthetic_ptr) { |
2932 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); | 2929 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); |
2933 (*is_synthetic_ptr) = method_oop->is_synthetic(); | 2930 (*is_synthetic_ptr) = method_oop->is_synthetic(); |
2934 return JVMTI_ERROR_NONE; | 2931 return JVMTI_ERROR_NONE; |
2935 } /* end IsMethodSynthetic */ | 2932 } /* end IsMethodSynthetic */ |
2936 | 2933 |
2937 | 2934 |
2938 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method | 2935 // method_oop - pre-checked for validity, but may be NULL meaning obsolete method |
2939 // is_obsolete_ptr - pre-checked for NULL | 2936 // is_obsolete_ptr - pre-checked for NULL |
2940 jvmtiError | 2937 jvmtiError |
2941 JvmtiEnv::IsMethodObsolete(methodOop method_oop, jboolean* is_obsolete_ptr) { | 2938 JvmtiEnv::IsMethodObsolete(Method* method_oop, jboolean* is_obsolete_ptr) { |
2942 if (use_version_1_0_semantics() && | 2939 if (use_version_1_0_semantics() && |
2943 get_capabilities()->can_redefine_classes == 0) { | 2940 get_capabilities()->can_redefine_classes == 0) { |
2944 // This JvmtiEnv requested version 1.0 semantics and this function | 2941 // This JvmtiEnv requested version 1.0 semantics and this function |
2945 // requires the can_redefine_classes capability in version 1.0 so | 2942 // requires the can_redefine_classes capability in version 1.0 so |
2946 // we need to return an error here. | 2943 // we need to return an error here. |