27
28 #include "ci/ciConstantPoolCache.hpp"
29 #include "ci/ciFlags.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciSymbol.hpp"
32 #include "oops/instanceKlass.hpp"
33
34 // ciInstanceKlass
35 //
36 // This class represents a Klass* in the HotSpot virtual machine
37 // whose Klass part is an InstanceKlass. It may or may not
38 // be loaded.
39 class ciInstanceKlass : public ciKlass {
40 CI_PACKAGE_ACCESS
41 friend class ciBytecodeStream;
42 friend class ciEnv;
43 friend class ciExceptionHandler;
44 friend class ciMethod;
45 friend class ciField;
46 friend class ciReplay;
47
48 private:
49 enum SubklassValue { subklass_unknown, subklass_false, subklass_true };
50
51 jobject _loader;
52
53 InstanceKlass::ClassState _init_state; // state of class
54 bool _is_shared;
55 bool _has_finalizer;
56 SubklassValue _has_subklass;
57 bool _has_nonstatic_fields;
58 bool _has_nonstatic_concrete_methods;
59 bool _is_hidden;
60 bool _is_record;
61 bool _has_trusted_loader;
62
63 ciFlags _flags;
64
65 // Lazy fields get filled in only upon request.
66 ciInstanceKlass* _super;
98
99 void print_impl(outputStream* st);
100
101 ciConstantPoolCache* field_cache();
102
103 bool is_shared() { return _is_shared; }
104
105 void compute_shared_init_state();
106 bool compute_shared_has_subklass();
107 int compute_nonstatic_fields();
108 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
109 bool compute_has_trusted_loader();
110
111 // Update the init_state for shared klasses
112 void update_if_shared(InstanceKlass::ClassState expected) {
113 if (_is_shared && _init_state != expected) {
114 if (is_loaded()) compute_shared_init_state();
115 }
116 }
117
118 public:
119 // Has this klass been initialized?
120 bool is_initialized() {
121 update_if_shared(InstanceKlass::fully_initialized);
122 return _init_state == InstanceKlass::fully_initialized;
123 }
124 bool is_not_initialized() {
125 update_if_shared(InstanceKlass::fully_initialized);
126 return _init_state < InstanceKlass::being_initialized;
127 }
128 // Is this klass being initialized?
129 bool is_being_initialized() {
130 update_if_shared(InstanceKlass::being_initialized);
131 return _init_state == InstanceKlass::being_initialized;
132 }
133 // Has this klass been linked?
134 bool is_linked() {
135 update_if_shared(InstanceKlass::linked);
136 return _init_state >= InstanceKlass::linked;
137 }
|
27
28 #include "ci/ciConstantPoolCache.hpp"
29 #include "ci/ciFlags.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciSymbol.hpp"
32 #include "oops/instanceKlass.hpp"
33
34 // ciInstanceKlass
35 //
36 // This class represents a Klass* in the HotSpot virtual machine
37 // whose Klass part is an InstanceKlass. It may or may not
38 // be loaded.
39 class ciInstanceKlass : public ciKlass {
40 CI_PACKAGE_ACCESS
41 friend class ciBytecodeStream;
42 friend class ciEnv;
43 friend class ciExceptionHandler;
44 friend class ciMethod;
45 friend class ciField;
46 friend class ciReplay;
47 friend class CompileTrainingData;
48
49 private:
50 enum SubklassValue { subklass_unknown, subklass_false, subklass_true };
51
52 jobject _loader;
53
54 InstanceKlass::ClassState _init_state; // state of class
55 bool _is_shared;
56 bool _has_finalizer;
57 SubklassValue _has_subklass;
58 bool _has_nonstatic_fields;
59 bool _has_nonstatic_concrete_methods;
60 bool _is_hidden;
61 bool _is_record;
62 bool _has_trusted_loader;
63
64 ciFlags _flags;
65
66 // Lazy fields get filled in only upon request.
67 ciInstanceKlass* _super;
99
100 void print_impl(outputStream* st);
101
102 ciConstantPoolCache* field_cache();
103
104 bool is_shared() { return _is_shared; }
105
106 void compute_shared_init_state();
107 bool compute_shared_has_subklass();
108 int compute_nonstatic_fields();
109 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
110 bool compute_has_trusted_loader();
111
112 // Update the init_state for shared klasses
113 void update_if_shared(InstanceKlass::ClassState expected) {
114 if (_is_shared && _init_state != expected) {
115 if (is_loaded()) compute_shared_init_state();
116 }
117 }
118
119 static InstanceKlass::ClassState compute_init_state(InstanceKlass* ik);
120
121 public:
122 // Has this klass been initialized?
123 bool is_initialized() {
124 update_if_shared(InstanceKlass::fully_initialized);
125 return _init_state == InstanceKlass::fully_initialized;
126 }
127 bool is_not_initialized() {
128 update_if_shared(InstanceKlass::fully_initialized);
129 return _init_state < InstanceKlass::being_initialized;
130 }
131 // Is this klass being initialized?
132 bool is_being_initialized() {
133 update_if_shared(InstanceKlass::being_initialized);
134 return _init_state == InstanceKlass::being_initialized;
135 }
136 // Has this klass been linked?
137 bool is_linked() {
138 update_if_shared(InstanceKlass::linked);
139 return _init_state >= InstanceKlass::linked;
140 }
|