89 ciInstanceKlass(Klass* k);
90 ciInstanceKlass(ciSymbol* name, jobject loader);
91
92 InstanceKlass* get_instanceKlass() const {
93 return InstanceKlass::cast(get_Klass());
94 }
95
96 oop loader();
97 jobject loader_handle();
98
99 const char* type_string() { return "ciInstanceKlass"; }
100
101 bool is_in_package_impl(const char* packagename, int len);
102
103 void print_impl(outputStream* st);
104
105 ciConstantPoolCache* field_cache();
106
107 bool is_shared() { return _is_shared; }
108
109 void compute_shared_init_state();
110 bool compute_shared_has_subklass();
111 int compute_nonstatic_fields();
112 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
113 bool compute_has_trusted_loader();
114
115 // Update the init_state for shared klasses
116 void update_if_shared(InstanceKlass::ClassState expected) {
117 if (_is_shared && _init_state != expected) {
118 if (is_loaded()) compute_shared_init_state();
119 }
120 }
121
122 public:
123 // Has this klass been initialized?
124 bool is_initialized() {
125 update_if_shared(InstanceKlass::fully_initialized);
126 return _init_state == InstanceKlass::fully_initialized;
127 }
128 bool is_not_initialized() {
129 update_if_shared(InstanceKlass::fully_initialized);
130 return _init_state < InstanceKlass::being_initialized;
131 }
132 // Is this klass being initialized?
133 bool is_being_initialized() {
134 update_if_shared(InstanceKlass::being_initialized);
135 return _init_state == InstanceKlass::being_initialized;
136 }
137 // Has this klass been linked?
138 bool is_linked() {
139 update_if_shared(InstanceKlass::linked);
140 return _init_state >= InstanceKlass::linked;
141 }
142 // Is this klass in error state?
143 bool is_in_error_state() {
144 update_if_shared(InstanceKlass::initialization_error);
145 return _init_state == InstanceKlass::initialization_error;
146 }
147
148 // General klass information.
149 ciFlags flags() {
150 assert(is_loaded(), "must be loaded");
151 return _flags;
152 }
153
154 // Fetch Klass::access_flags.
155 jint access_flags() { return flags().as_int(); }
156
157 bool has_finalizer() {
158 assert(is_loaded(), "must be loaded");
159 return _has_finalizer; }
160 bool has_subklass() {
161 assert(is_loaded(), "must be loaded");
162 // Ignore cached subklass_false case.
163 // It could be invalidated by concurrent class loading and
164 // can result in type paradoxes during compilation when
165 // a subclass is observed, but has_subklass() returns false.
|
89 ciInstanceKlass(Klass* k);
90 ciInstanceKlass(ciSymbol* name, jobject loader);
91
92 InstanceKlass* get_instanceKlass() const {
93 return InstanceKlass::cast(get_Klass());
94 }
95
96 oop loader();
97 jobject loader_handle();
98
99 const char* type_string() { return "ciInstanceKlass"; }
100
101 bool is_in_package_impl(const char* packagename, int len);
102
103 void print_impl(outputStream* st);
104
105 ciConstantPoolCache* field_cache();
106
107 bool is_shared() { return _is_shared; }
108
109 InstanceKlass::ClassState compute_shared_init_state();
110 bool compute_shared_has_subklass();
111 int compute_nonstatic_fields();
112 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
113 bool compute_has_trusted_loader();
114
115 // Update the init_state for shared klasses
116 InstanceKlass::ClassState update_if_shared() {
117 if (_is_shared && is_loaded()) {
118 return compute_shared_init_state();
119 }
120 return _init_state;
121 }
122
123 static InstanceKlass::ClassState compute_init_state(InstanceKlass* ik);
124
125 public:
126 // Has this klass been initialized?
127 bool is_initialized() {
128 InstanceKlass::ClassState state = update_if_shared();
129 return state == InstanceKlass::fully_initialized;
130 }
131 bool is_not_initialized() {
132 InstanceKlass::ClassState state = update_if_shared();
133 return state < InstanceKlass::being_initialized;
134 }
135 // Is this klass being initialized?
136 bool is_being_initialized() {
137 InstanceKlass::ClassState state = update_if_shared();
138 return state == InstanceKlass::being_initialized;
139 }
140 // Has this klass been linked?
141 bool is_linked() {
142 InstanceKlass::ClassState state = update_if_shared();
143 return state >= InstanceKlass::linked;
144 }
145 // Is this klass in error state?
146 bool is_in_error_state() {
147 InstanceKlass::ClassState state = update_if_shared();
148 return state == InstanceKlass::initialization_error;
149 }
150
151 // General klass information.
152 ciFlags flags() {
153 assert(is_loaded(), "must be loaded");
154 return _flags;
155 }
156
157 // Fetch Klass::access_flags.
158 jint access_flags() { return flags().as_int(); }
159
160 bool has_finalizer() {
161 assert(is_loaded(), "must be loaded");
162 return _has_finalizer; }
163 bool has_subklass() {
164 assert(is_loaded(), "must be loaded");
165 // Ignore cached subklass_false case.
166 // It could be invalidated by concurrent class loading and
167 // can result in type paradoxes during compilation when
168 // a subclass is observed, but has_subklass() returns false.
|