61
62 oop ArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
63 ShouldNotReachHere();
64 return NULL;
65 }
66
67 Method* ArrayKlass::uncached_lookup_method(Symbol* name, Symbol* signature, MethodLookupMode mode) const {
68 // There are no methods in an array klass but the super class (Object) has some
69 assert(super(), "super klass must be present");
70 return super()->uncached_lookup_method(name, signature, mode);
71 }
72
73 ArrayKlass::ArrayKlass(Symbol* name) {
74 set_name(name);
75
76 set_super(Universe::is_bootstrapping() ? (Klass*)NULL : SystemDictionary::Object_klass());
77 set_layout_helper(Klass::_lh_neutral_value);
78 set_dimension(1);
79 set_higher_dimension(NULL);
80 set_lower_dimension(NULL);
81 set_component_mirror(NULL);
82 // Arrays don't add any new methods, so their vtable is the same size as
83 // the vtable of klass Object.
84 int vtable_size = Universe::base_vtable_size();
85 set_vtable_length(vtable_size);
86 set_is_cloneable(); // All arrays are considered to be cloneable (See JLS 20.1.5)
87 }
88
89
90 // Initialization of vtables and mirror object is done separatly from base_create_array_klass,
91 // since a GC can happen. At this point all instance variables of the ArrayKlass must be setup.
92 void ArrayKlass::complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS) {
93 ResourceMark rm(THREAD);
94 k->initialize_supers(super_klass(), CHECK);
95 k->vtable()->initialize_vtable(false, CHECK);
96 java_lang_Class::create_mirror(k, Handle(NULL), Handle(NULL), CHECK);
97 }
98
99 GrowableArray<Klass*>* ArrayKlass::compute_secondary_supers(int num_extra_slots) {
100 // interfaces = { cloneable_klass, serializable_klass };
101 assert(num_extra_slots == 0, "sanity of primitive array type");
143 }
144
145 void ArrayKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
146 Klass* k = this;
147 // Iterate over this array klass and all higher dimensions
148 while (k != NULL) {
149 f(k, CHECK);
150 k = ArrayKlass::cast(k)->higher_dimension();
151 }
152 }
153
154 void ArrayKlass::array_klasses_do(void f(Klass* k)) {
155 Klass* k = this;
156 // Iterate over this array klass and all higher dimensions
157 while (k != NULL) {
158 f(k);
159 k = ArrayKlass::cast(k)->higher_dimension();
160 }
161 }
162
163 // GC support
164
165 void ArrayKlass::oops_do(OopClosure* cl) {
166 Klass::oops_do(cl);
167
168 cl->do_oop(adr_component_mirror());
169 }
170
171 // JVM support
172
173 jint ArrayKlass::compute_modifier_flags(TRAPS) const {
174 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
175 }
176
177 // JVMTI support
178
179 jint ArrayKlass::jvmti_class_status() const {
180 return JVMTI_CLASS_STATUS_ARRAY;
181 }
182
183 void ArrayKlass::remove_unshareable_info() {
184 Klass::remove_unshareable_info();
185 // Clear the java mirror
186 set_component_mirror(NULL);
187 }
188
189 void ArrayKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
190 assert(loader_data == ClassLoaderData::the_null_class_loader_data(), "array classes belong to null loader");
191 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
192 // Klass recreates the component mirror also
193 }
194
195 // Printing
196
197 void ArrayKlass::print_on(outputStream* st) const {
198 assert(is_klass(), "must be klass");
199 Klass::print_on(st);
200 }
201
202 void ArrayKlass::print_value_on(outputStream* st) const {
203 assert(is_klass(), "must be klass");
204 for(int index = 0; index < dimension(); index++) {
205 st->print("[]");
206 }
207 }
208
209 void ArrayKlass::oop_print_on(oop obj, outputStream* st) {
210 assert(obj->is_array(), "must be array");
211 Klass::oop_print_on(obj, st);
212 st->print_cr(" - length: %d", arrayOop(obj)->length());
213 }
214
215
216 // Verification
217
218 void ArrayKlass::verify_on(outputStream* st) {
219 Klass::verify_on(st);
220
221 if (component_mirror() != NULL) {
222 guarantee(component_mirror()->klass() != NULL, "should have a class");
223 }
224 }
225
226 void ArrayKlass::oop_verify_on(oop obj, outputStream* st) {
227 guarantee(obj->is_array(), "must be array");
228 arrayOop a = arrayOop(obj);
229 guarantee(a->length() >= 0, "array with negative length?");
230 }
|
61
62 oop ArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
63 ShouldNotReachHere();
64 return NULL;
65 }
66
67 Method* ArrayKlass::uncached_lookup_method(Symbol* name, Symbol* signature, MethodLookupMode mode) const {
68 // There are no methods in an array klass but the super class (Object) has some
69 assert(super(), "super klass must be present");
70 return super()->uncached_lookup_method(name, signature, mode);
71 }
72
73 ArrayKlass::ArrayKlass(Symbol* name) {
74 set_name(name);
75
76 set_super(Universe::is_bootstrapping() ? (Klass*)NULL : SystemDictionary::Object_klass());
77 set_layout_helper(Klass::_lh_neutral_value);
78 set_dimension(1);
79 set_higher_dimension(NULL);
80 set_lower_dimension(NULL);
81 // Arrays don't add any new methods, so their vtable is the same size as
82 // the vtable of klass Object.
83 int vtable_size = Universe::base_vtable_size();
84 set_vtable_length(vtable_size);
85 set_is_cloneable(); // All arrays are considered to be cloneable (See JLS 20.1.5)
86 }
87
88
89 // Initialization of vtables and mirror object is done separatly from base_create_array_klass,
90 // since a GC can happen. At this point all instance variables of the ArrayKlass must be setup.
91 void ArrayKlass::complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS) {
92 ResourceMark rm(THREAD);
93 k->initialize_supers(super_klass(), CHECK);
94 k->vtable()->initialize_vtable(false, CHECK);
95 java_lang_Class::create_mirror(k, Handle(NULL), Handle(NULL), CHECK);
96 }
97
98 GrowableArray<Klass*>* ArrayKlass::compute_secondary_supers(int num_extra_slots) {
99 // interfaces = { cloneable_klass, serializable_klass };
100 assert(num_extra_slots == 0, "sanity of primitive array type");
142 }
143
144 void ArrayKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
145 Klass* k = this;
146 // Iterate over this array klass and all higher dimensions
147 while (k != NULL) {
148 f(k, CHECK);
149 k = ArrayKlass::cast(k)->higher_dimension();
150 }
151 }
152
153 void ArrayKlass::array_klasses_do(void f(Klass* k)) {
154 Klass* k = this;
155 // Iterate over this array klass and all higher dimensions
156 while (k != NULL) {
157 f(k);
158 k = ArrayKlass::cast(k)->higher_dimension();
159 }
160 }
161
162 // JVM support
163
164 jint ArrayKlass::compute_modifier_flags(TRAPS) const {
165 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
166 }
167
168 // JVMTI support
169
170 jint ArrayKlass::jvmti_class_status() const {
171 return JVMTI_CLASS_STATUS_ARRAY;
172 }
173
174 void ArrayKlass::remove_unshareable_info() {
175 Klass::remove_unshareable_info();
176 }
177
178 void ArrayKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
179 assert(loader_data == ClassLoaderData::the_null_class_loader_data(), "array classes belong to null loader");
180 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
181 // Klass recreates the component mirror also
182 }
183
184 // Printing
185
186 void ArrayKlass::print_on(outputStream* st) const {
187 assert(is_klass(), "must be klass");
188 Klass::print_on(st);
189 }
190
191 void ArrayKlass::print_value_on(outputStream* st) const {
192 assert(is_klass(), "must be klass");
193 for(int index = 0; index < dimension(); index++) {
194 st->print("[]");
195 }
196 }
197
198 void ArrayKlass::oop_print_on(oop obj, outputStream* st) {
199 assert(obj->is_array(), "must be array");
200 Klass::oop_print_on(obj, st);
201 st->print_cr(" - length: %d", arrayOop(obj)->length());
202 }
203
204
205 // Verification
206
207 void ArrayKlass::verify_on(outputStream* st) {
208 Klass::verify_on(st);
209 }
210
211 void ArrayKlass::oop_verify_on(oop obj, outputStream* st) {
212 guarantee(obj->is_array(), "must be array");
213 arrayOop a = arrayOop(obj);
214 guarantee(a->length() >= 0, "array with negative length?");
215 }
|