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);
3607 m = methods()->at(index);
3608 if (m->orig_method_idnum() == idnum) {
3609 return m;
3610 }
3611 }
3612 // None found, return null for the caller to handle.
3613 return NULL;
3614 }
3615
3616
3617 Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) {
3618 InstanceKlass* holder = get_klass_version(version);
3619 if (holder == NULL) {
3620 return NULL; // The version of klass is gone, no method is found
3621 }
3622 Method* method = holder->method_with_orig_idnum(idnum);
3623 return method;
3624 }
3625
3626 #if INCLUDE_JVMTI
3627 jint InstanceKlass::get_cached_class_file_len() {
3628 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
3629 }
3630
3631 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
3632 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
3633 }
3634 #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);
3603 m = methods()->at(index);
3604 if (m->orig_method_idnum() == idnum) {
3605 return m;
3606 }
3607 }
3608 // None found, return null for the caller to handle.
3609 return NULL;
3610 }
3611
3612
3613 Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) {
3614 InstanceKlass* holder = get_klass_version(version);
3615 if (holder == NULL) {
3616 return NULL; // The version of klass is gone, no method is found
3617 }
3618 Method* method = holder->method_with_orig_idnum(idnum);
3619 return method;
3620 }
3621
3622 #if INCLUDE_JVMTI
3623 JvmtiCachedClassFileData* InstanceKlass::get_cached_class_file() {
3624 if (MetaspaceShared::is_in_shared_space(_cached_class_file)) {
3625 // Ignore the archived class stream data
3626 return NULL;
3627 } else {
3628 return _cached_class_file;
3629 }
3630 }
3631
3632 jint InstanceKlass::get_cached_class_file_len() {
3633 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
3634 }
3635
3636 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
3637 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
3638 }
3639
3640 #if INCLUDE_CDS
3641 JvmtiCachedClassFileData* InstanceKlass::get_archived_class_data() {
3642 assert(this->is_shared(), "class is not shared");
3643 if (MetaspaceShared::is_in_shared_space(_cached_class_file)) {
3644 return _cached_class_file;
3645 } else {
3646 return NULL;
3647 }
3648 }
3649 #endif
3650 #endif
|