50 jobject _protection_domain;
51
52 InstanceKlass::ClassState _init_state; // state of class
53 bool _is_shared;
54 bool _has_finalizer;
55 SubklassValue _has_subklass;
56 bool _has_nonstatic_fields;
57 bool _has_nonstatic_concrete_methods;
58 bool _is_unsafe_anonymous;
59
60 ciFlags _flags;
61 jint _nonstatic_field_size;
62 jint _nonstatic_oop_map_size;
63
64 // Lazy fields get filled in only upon request.
65 ciInstanceKlass* _super;
66 ciInstance* _java_mirror;
67
68 ciConstantPoolCache* _field_cache; // cached map index->field
69 GrowableArray<ciField*>* _nonstatic_fields;
70 int _has_injected_fields; // any non static injected fields? lazily initialized.
71
72 // The possible values of the _implementor fall into following three cases:
73 // NULL: no implementor.
74 // A ciInstanceKlass that's not itself: one implementor.
75 // Itself: more than one implementor.
76 ciInstanceKlass* _implementor;
77
78 void compute_injected_fields();
79 bool compute_injected_fields_helper();
80
81 protected:
82 ciInstanceKlass(Klass* k);
83 ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain);
84
85 InstanceKlass* get_instanceKlass() const {
86 return InstanceKlass::cast(get_Klass());
87 }
88
89 oop loader();
90 jobject loader_handle();
91
92 oop protection_domain();
93 jobject protection_domain_handle();
94
95 const char* type_string() { return "ciInstanceKlass"; }
96
97 bool is_in_package_impl(const char* packagename, int len);
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
110 // Update the init_state for shared klasses
111 void update_if_shared(InstanceKlass::ClassState expected) {
112 if (_is_shared && _init_state != expected) {
113 if (is_loaded()) compute_shared_init_state();
114 }
115 }
116
117 public:
118 // Has this klass been initialized?
119 bool is_initialized() {
120 update_if_shared(InstanceKlass::fully_initialized);
121 return _init_state == InstanceKlass::fully_initialized;
122 }
123 // Is this klass being initialized?
124 bool is_being_initialized() {
125 update_if_shared(InstanceKlass::being_initialized);
126 return _init_state == InstanceKlass::being_initialized;
127 }
128 // Has this klass been linked?
172 if (impl == NULL) {
173 return 0;
174 } else if (impl != this) {
175 return 1;
176 } else {
177 return 2;
178 }
179 }
180 bool has_nonstatic_concrete_methods() {
181 assert(is_loaded(), "must be loaded");
182 return _has_nonstatic_concrete_methods;
183 }
184
185 bool is_unsafe_anonymous() {
186 return _is_unsafe_anonymous;
187 }
188
189 ciInstanceKlass* get_canonical_holder(int offset);
190 ciField* get_field_by_offset(int field_offset, bool is_static);
191 ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static);
192
193 // total number of nonstatic fields (including inherited):
194 int nof_nonstatic_fields() {
195 if (_nonstatic_fields == NULL)
196 return compute_nonstatic_fields();
197 else
198 return _nonstatic_fields->length();
199 }
200
201 bool has_injected_fields() {
202 if (_has_injected_fields == -1) {
203 compute_injected_fields();
204 }
205 return _has_injected_fields > 0 ? true : false;
206 }
207
208 bool has_object_fields() const;
209
210 // nth nonstatic field (presented by ascending address)
211 ciField* nonstatic_field_at(int i) {
212 assert(_nonstatic_fields != NULL, "");
213 return _nonstatic_fields->at(i);
214 }
215
216 ciInstanceKlass* unique_concrete_subklass();
217 bool has_finalizable_subclass();
218
219 bool contains_field_offset(int offset) {
220 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
221 }
222
223 // Get the instance of java.lang.Class corresponding to
224 // this klass. This instance is used for locking of
225 // synchronized static methods of this klass.
226 ciInstance* java_mirror();
227
228 // Java access flags
229 bool is_public () { return flags().is_public(); }
230 bool is_final () { return flags().is_final(); }
231 bool is_super () { return flags().is_super(); }
232 bool is_interface () { return flags().is_interface(); }
233 bool is_abstract () { return flags().is_abstract(); }
234
235 ciMethod* find_method(ciSymbol* name, ciSymbol* signature);
236 // Note: To find a method from name and type strings, use ciSymbol::make,
237 // but consider adding to vmSymbols.hpp instead.
238
239 bool is_leaf_type();
240 ciInstanceKlass* implementor();
241
242 // Is the defining class loader of this class the default loader?
243 bool uses_default_loader() const;
244
245 bool is_java_lang_Object() const;
246
247 BasicType box_klass_type() const;
248 bool is_box_klass() const;
249 bool is_boxed_value_offset(int offset) const;
250
251 // Is this klass in the given package?
252 bool is_in_package(const char* packagename) {
253 return is_in_package(packagename, (int) strlen(packagename));
254 }
255 bool is_in_package(const char* packagename, int len);
256
257 // What kind of ciObject is this?
258 bool is_instance_klass() const { return true; }
259 bool is_java_klass() const { return true; }
260
|
50 jobject _protection_domain;
51
52 InstanceKlass::ClassState _init_state; // state of class
53 bool _is_shared;
54 bool _has_finalizer;
55 SubklassValue _has_subklass;
56 bool _has_nonstatic_fields;
57 bool _has_nonstatic_concrete_methods;
58 bool _is_unsafe_anonymous;
59
60 ciFlags _flags;
61 jint _nonstatic_field_size;
62 jint _nonstatic_oop_map_size;
63
64 // Lazy fields get filled in only upon request.
65 ciInstanceKlass* _super;
66 ciInstance* _java_mirror;
67
68 ciConstantPoolCache* _field_cache; // cached map index->field
69 GrowableArray<ciField*>* _nonstatic_fields;
70
71 int _has_injected_fields; // any non static injected fields? lazily initialized.
72
73 ciInstanceKlass* _vcc_klass; // points to the value-capable class corresponding to the current derived value type class.
74
75 // The possible values of the _implementor fall into following three cases:
76 // NULL: no implementor.
77 // A ciInstanceKlass that's not itself: one implementor.
78 // Itself: more than one implementor.
79 ciInstanceKlass* _implementor;
80
81 void compute_injected_fields();
82 bool compute_injected_fields_helper();
83
84 protected:
85 ciInstanceKlass(Klass* k);
86 ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain, BasicType bt = T_OBJECT); // for unloaded klasses
87
88 InstanceKlass* get_instanceKlass() const {
89 return InstanceKlass::cast(get_Klass());
90 }
91
92 oop loader();
93 jobject loader_handle();
94
95 oop protection_domain();
96 jobject protection_domain_handle();
97
98 const char* type_string() { return "ciInstanceKlass"; }
99
100 bool is_in_package_impl(const char* packagename, int len);
101
102 void print_impl(outputStream* st);
103
104 ciConstantPoolCache* field_cache();
105
106 bool is_shared() { return _is_shared; }
107
108 void compute_shared_init_state();
109 bool compute_shared_has_subklass();
110 virtual int compute_nonstatic_fields();
111 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields, bool flatten = true);
112
113 // Update the init_state for shared klasses
114 void update_if_shared(InstanceKlass::ClassState expected) {
115 if (_is_shared && _init_state != expected) {
116 if (is_loaded()) compute_shared_init_state();
117 }
118 }
119
120 public:
121 // Has this klass been initialized?
122 bool is_initialized() {
123 update_if_shared(InstanceKlass::fully_initialized);
124 return _init_state == InstanceKlass::fully_initialized;
125 }
126 // Is this klass being initialized?
127 bool is_being_initialized() {
128 update_if_shared(InstanceKlass::being_initialized);
129 return _init_state == InstanceKlass::being_initialized;
130 }
131 // Has this klass been linked?
175 if (impl == NULL) {
176 return 0;
177 } else if (impl != this) {
178 return 1;
179 } else {
180 return 2;
181 }
182 }
183 bool has_nonstatic_concrete_methods() {
184 assert(is_loaded(), "must be loaded");
185 return _has_nonstatic_concrete_methods;
186 }
187
188 bool is_unsafe_anonymous() {
189 return _is_unsafe_anonymous;
190 }
191
192 ciInstanceKlass* get_canonical_holder(int offset);
193 ciField* get_field_by_offset(int field_offset, bool is_static);
194 ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static);
195 // get field descriptor at field_offset ignoring flattening
196 ciField* get_non_flattened_field_by_offset(int field_offset);
197
198 // total number of nonstatic fields (including inherited):
199 int nof_nonstatic_fields() {
200 if (_nonstatic_fields == NULL) {
201 return compute_nonstatic_fields();
202 } else {
203 return _nonstatic_fields->length();
204 }
205 }
206
207 bool has_injected_fields() {
208 if (_has_injected_fields == -1) {
209 compute_injected_fields();
210 }
211 return _has_injected_fields > 0 ? true : false;
212 }
213
214 bool has_object_fields() const;
215
216 // nth nonstatic field (presented by ascending address)
217 ciField* nonstatic_field_at(int i) {
218 assert(_nonstatic_fields != NULL, "");
219 return _nonstatic_fields->at(i);
220 }
221
222 ciInstanceKlass* unique_concrete_subklass();
223 bool has_finalizable_subclass();
224
225 bool contains_field_offset(int offset) {
226 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size(), is_valuetype());
227 }
228
229 // Get the instance of java.lang.Class corresponding to
230 // this klass. This instance is used for locking of
231 // synchronized static methods of this klass.
232 ciInstance* java_mirror();
233
234 // Java access flags
235 bool is_public () { return flags().is_public(); }
236 bool is_final () { return flags().is_final(); }
237 bool is_super () { return flags().is_super(); }
238 bool is_interface () { return flags().is_interface(); }
239 bool is_abstract () { return flags().is_abstract(); }
240
241 ciMethod* find_method(ciSymbol* name, ciSymbol* signature);
242 // Note: To find a method from name and type strings, use ciSymbol::make,
243 // but consider adding to vmSymbols.hpp instead.
244
245 bool is_leaf_type();
246 ciInstanceKlass* implementor();
247 ciInstanceKlass* vcc_klass();
248
249 // Is the defining class loader of this class the default loader?
250 bool uses_default_loader() const;
251
252 bool is_java_lang_Object() const;
253
254 BasicType box_klass_type() const;
255 bool is_box_klass() const;
256 bool is_boxed_value_offset(int offset) const;
257
258 // Is this klass in the given package?
259 bool is_in_package(const char* packagename) {
260 return is_in_package(packagename, (int) strlen(packagename));
261 }
262 bool is_in_package(const char* packagename, int len);
263
264 // What kind of ciObject is this?
265 bool is_instance_klass() const { return true; }
266 bool is_java_klass() const { return true; }
267
|