24
25 #include "precompiled.hpp"
26 #include "classfile/classFileParser.hpp"
27 #include "classfile/classFileStream.hpp"
28 #include "classfile/javaClasses.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "classfile/systemDictionaryShared.hpp"
31 #include "classfile/verifier.hpp"
32 #include "classfile/vmSymbols.hpp"
33 #include "code/dependencyContext.hpp"
34 #include "compiler/compileBroker.hpp"
35 #include "gc/shared/collectedHeap.inline.hpp"
36 #include "gc/shared/specialized_oop_closures.hpp"
37 #include "interpreter/oopMapCache.hpp"
38 #include "interpreter/rewriter.hpp"
39 #include "jvmtifiles/jvmti.h"
40 #include "logging/log.hpp"
41 #include "memory/heapInspection.hpp"
42 #include "memory/iterator.inline.hpp"
43 #include "memory/metadataFactory.hpp"
44 #include "memory/oopFactory.hpp"
45 #include "memory/resourceArea.hpp"
46 #include "oops/fieldStreams.hpp"
47 #include "oops/instanceClassLoaderKlass.hpp"
48 #include "oops/instanceKlass.inline.hpp"
49 #include "oops/instanceMirrorKlass.hpp"
50 #include "oops/instanceOop.hpp"
51 #include "oops/klass.inline.hpp"
52 #include "oops/method.hpp"
53 #include "oops/oop.inline.hpp"
54 #include "oops/symbol.hpp"
55 #include "prims/jvmtiExport.hpp"
56 #include "prims/jvmtiRedefineClasses.hpp"
57 #include "prims/jvmtiThreadState.hpp"
58 #include "prims/methodComparator.hpp"
59 #include "runtime/atomic.hpp"
60 #include "runtime/fieldDescriptor.hpp"
61 #include "runtime/handles.inline.hpp"
62 #include "runtime/javaCalls.hpp"
63 #include "runtime/mutexLocker.hpp"
1955 k->remove_unshareable_info();
1956 }
1957
1958 void InstanceKlass::remove_unshareable_info() {
1959 Klass::remove_unshareable_info();
1960 // Unlink the class
1961 if (is_linked()) {
1962 unlink_class();
1963 }
1964 init_implementor();
1965
1966 constants()->remove_unshareable_info();
1967
1968 assert(_dep_context == DependencyContext::EMPTY, "dependency context is not shareable");
1969
1970 for (int i = 0; i < methods()->length(); i++) {
1971 Method* m = methods()->at(i);
1972 m->remove_unshareable_info();
1973 }
1974
1975 // cached_class_file might be pointing to a malloc'ed buffer allocated by
1976 // event-based tracing code at CDS dump time. It's not usable at runtime
1977 // so let's clear it.
1978 set_cached_class_file(NULL);
1979
1980 // do array classes also.
1981 array_klasses_do(remove_unshareable_in_class);
1982 }
1983
1984 static void restore_unshareable_in_class(Klass* k, TRAPS) {
1985 // Array classes have null protection domain.
1986 // --> see ArrayKlass::complete_create_array_klass()
1987 k->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
1988 }
1989
1990 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
1991 instanceKlassHandle ik(THREAD, this);
1992 ik->set_package(loader_data, CHECK);
1993 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
1994
1995 Array<Method*>* methods = ik->methods();
1996 int num_methods = methods->length();
1997 for (int index2 = 0; index2 < num_methods; ++index2) {
1998 methodHandle m(THREAD, methods->at(index2));
1999 m->restore_unshareable_info(CHECK);
3636 m = methods()->at(index);
3637 if (m->orig_method_idnum() == idnum) {
3638 return m;
3639 }
3640 }
3641 // None found, return null for the caller to handle.
3642 return NULL;
3643 }
3644
3645
3646 Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) {
3647 InstanceKlass* holder = get_klass_version(version);
3648 if (holder == NULL) {
3649 return NULL; // The version of klass is gone, no method is found
3650 }
3651 Method* method = holder->method_with_orig_idnum(idnum);
3652 return method;
3653 }
3654
3655 #if INCLUDE_JVMTI
3656 jint InstanceKlass::get_cached_class_file_len() {
3657 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
3658 }
3659
3660 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
3661 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
3662 }
3663 #endif
|
24
25 #include "precompiled.hpp"
26 #include "classfile/classFileParser.hpp"
27 #include "classfile/classFileStream.hpp"
28 #include "classfile/javaClasses.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "classfile/systemDictionaryShared.hpp"
31 #include "classfile/verifier.hpp"
32 #include "classfile/vmSymbols.hpp"
33 #include "code/dependencyContext.hpp"
34 #include "compiler/compileBroker.hpp"
35 #include "gc/shared/collectedHeap.inline.hpp"
36 #include "gc/shared/specialized_oop_closures.hpp"
37 #include "interpreter/oopMapCache.hpp"
38 #include "interpreter/rewriter.hpp"
39 #include "jvmtifiles/jvmti.h"
40 #include "logging/log.hpp"
41 #include "memory/heapInspection.hpp"
42 #include "memory/iterator.inline.hpp"
43 #include "memory/metadataFactory.hpp"
44 #include "memory/metaspaceShared.hpp"
45 #include "memory/oopFactory.hpp"
46 #include "memory/resourceArea.hpp"
47 #include "oops/fieldStreams.hpp"
48 #include "oops/instanceClassLoaderKlass.hpp"
49 #include "oops/instanceKlass.inline.hpp"
50 #include "oops/instanceMirrorKlass.hpp"
51 #include "oops/instanceOop.hpp"
52 #include "oops/klass.inline.hpp"
53 #include "oops/method.hpp"
54 #include "oops/oop.inline.hpp"
55 #include "oops/symbol.hpp"
56 #include "prims/jvmtiExport.hpp"
57 #include "prims/jvmtiRedefineClasses.hpp"
58 #include "prims/jvmtiThreadState.hpp"
59 #include "prims/methodComparator.hpp"
60 #include "runtime/atomic.hpp"
61 #include "runtime/fieldDescriptor.hpp"
62 #include "runtime/handles.inline.hpp"
63 #include "runtime/javaCalls.hpp"
64 #include "runtime/mutexLocker.hpp"
1956 k->remove_unshareable_info();
1957 }
1958
1959 void InstanceKlass::remove_unshareable_info() {
1960 Klass::remove_unshareable_info();
1961 // Unlink the class
1962 if (is_linked()) {
1963 unlink_class();
1964 }
1965 init_implementor();
1966
1967 constants()->remove_unshareable_info();
1968
1969 assert(_dep_context == DependencyContext::EMPTY, "dependency context is not shareable");
1970
1971 for (int i = 0; i < methods()->length(); i++) {
1972 Method* m = methods()->at(i);
1973 m->remove_unshareable_info();
1974 }
1975
1976 // do array classes also.
1977 array_klasses_do(remove_unshareable_in_class);
1978 }
1979
1980 static void restore_unshareable_in_class(Klass* k, TRAPS) {
1981 // Array classes have null protection domain.
1982 // --> see ArrayKlass::complete_create_array_klass()
1983 k->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
1984 }
1985
1986 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
1987 instanceKlassHandle ik(THREAD, this);
1988 ik->set_package(loader_data, CHECK);
1989 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
1990
1991 Array<Method*>* methods = ik->methods();
1992 int num_methods = methods->length();
1993 for (int index2 = 0; index2 < num_methods; ++index2) {
1994 methodHandle m(THREAD, methods->at(index2));
1995 m->restore_unshareable_info(CHECK);
3632 m = methods()->at(index);
3633 if (m->orig_method_idnum() == idnum) {
3634 return m;
3635 }
3636 }
3637 // None found, return null for the caller to handle.
3638 return NULL;
3639 }
3640
3641
3642 Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) {
3643 InstanceKlass* holder = get_klass_version(version);
3644 if (holder == NULL) {
3645 return NULL; // The version of klass is gone, no method is found
3646 }
3647 Method* method = holder->method_with_orig_idnum(idnum);
3648 return method;
3649 }
3650
3651 #if INCLUDE_JVMTI
3652 JvmtiCachedClassFileData* InstanceKlass::get_cached_class_file() {
3653 if (MetaspaceShared::is_in_shared_space(_cached_class_file)) {
3654 // Ignore the archived class stream data
3655 return NULL;
3656 } else {
3657 return _cached_class_file;
3658 }
3659 }
3660
3661 jint InstanceKlass::get_cached_class_file_len() {
3662 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
3663 }
3664
3665 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
3666 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
3667 }
3668
3669 #if INCLUDE_CDS
3670 JvmtiCachedClassFileData* InstanceKlass::get_archived_class_data() {
3671 assert(this->is_shared(), "class is not shared");
3672 if (MetaspaceShared::is_in_shared_space(_cached_class_file)) {
3673 return _cached_class_file;
3674 } else {
3675 return NULL;
3676 }
3677 }
3678 #endif
3679 #endif
|