132 for (int i = 0; i < constant_pool_map_length; i++) {
133 int x = reference_map.at(i);
134 assert(x == (int)(jushort) x, "klass index is too big");
135 om->at_put(i, (jushort)x);
136 }
137 set_reference_map(om);
138 }
139
140 // Create Java array for holding resolved strings, methodHandles,
141 // methodTypes, invokedynamic and invokehandle appendix objects, etc.
142 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
143 Handle refs_handle (THREAD, (oop)stom); // must handleize.
144 set_resolved_references(loader_data->add_handle(refs_handle));
145 }
146 }
147
148 void ConstantPool::allocate_resolved_klasses(ClassLoaderData* loader_data, int num_klasses, TRAPS) {
149 // A ConstantPool can't possibly have 0xffff valid class entries,
150 // because entry #0 must be CONSTANT_Invalid, and each class entry must refer to a UTF8
151 // entry for the class's name. So at most we will have 0xfffe class entries.
152 // This allows us to use 0xffff (ConstantPool::_invalid_resolved_klass_index) to indicate
153 // UnresolvedKlass entries that are temporarily created during class redefinition.
154 assert(num_klasses < _invalid_resolved_klass_index, "sanity");
155 assert(resolved_klasses() == NULL, "sanity");
156 Array<Klass*>* rk = MetadataFactory::new_writeable_array<Klass*>(loader_data, num_klasses, CHECK);
157 set_resolved_klasses(rk);
158 }
159
160 void ConstantPool::initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS) {
161 int len = length();
162 int num_klasses = 0;
163 for (int i = 1; i <len; i++) {
164 switch (tag_at(i).value()) {
165 case JVM_CONSTANT_ClassIndex:
166 {
167 const int class_index = klass_index_at(i);
168 unresolved_klass_at_put(i, class_index, num_klasses++);
169 }
170 break;
171 #ifndef PRODUCT
172 case JVM_CONSTANT_Class:
173 case JVM_CONSTANT_UnresolvedClass:
174 case JVM_CONSTANT_UnresolvedClassInError:
175 // All of these should have been reverted back to ClassIndex before calling
176 // this function.
177 ShouldNotReachHere();
178 #endif
179 }
180 }
181 allocate_resolved_klasses(loader_data, num_klasses, THREAD);
182 }
183
184 void ConstantPool::klass_at_put(int which, int name_index, int resolved_klass_index, Klass* k, Symbol* name) {
185 assert(is_within_bounds(which), "index out of bounds");
186 assert(is_within_bounds(name_index), "index out of bounds");
187 assert((resolved_klass_index & 0xffff0000) == 0, "must be");
188 *int_at_addr(which) =
189 build_int_from_shorts((jushort)resolved_klass_index, (jushort)name_index);
190
191 symbol_at_put(name_index, name);
192 name->increment_refcount();
193 Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);
194 OrderAccess::release_store_ptr((Klass* volatile *)adr, k);
195
196 // The interpreter assumes when the tag is stored, the klass is resolved
197 // and the Klass* non-NULL, so we need hardware store ordering here.
198 if (k != NULL) {
199 release_tag_at_put(which, JVM_CONSTANT_Class);
200 } else {
201 release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass);
202 }
203 }
204
205 // CDS support. Create a new resolved_references array.
206 void ConstantPool::restore_unshareable_info(TRAPS) {
207 assert(is_constantPool(), "ensure C++ vtable is restored");
208 assert(on_stack(), "should always be set for shared constant pools");
209 assert(is_shared(), "should always be set for shared constant pools");
210
211 // Only create the new resolved references array if it hasn't been attempted before
212 if (resolved_references() != NULL) return;
213
214 // restore the C++ vtable from the shared archive
215 restore_vtable();
216
217 if (SystemDictionary::Object_klass_loaded()) {
218 // Recreate the object array and add to ClassLoaderData.
219 int map_length = resolved_reference_length();
220 if (map_length > 0) {
221 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
222 Handle refs_handle (THREAD, (oop)stom); // must handleize.
|
132 for (int i = 0; i < constant_pool_map_length; i++) {
133 int x = reference_map.at(i);
134 assert(x == (int)(jushort) x, "klass index is too big");
135 om->at_put(i, (jushort)x);
136 }
137 set_reference_map(om);
138 }
139
140 // Create Java array for holding resolved strings, methodHandles,
141 // methodTypes, invokedynamic and invokehandle appendix objects, etc.
142 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
143 Handle refs_handle (THREAD, (oop)stom); // must handleize.
144 set_resolved_references(loader_data->add_handle(refs_handle));
145 }
146 }
147
148 void ConstantPool::allocate_resolved_klasses(ClassLoaderData* loader_data, int num_klasses, TRAPS) {
149 // A ConstantPool can't possibly have 0xffff valid class entries,
150 // because entry #0 must be CONSTANT_Invalid, and each class entry must refer to a UTF8
151 // entry for the class's name. So at most we will have 0xfffe class entries.
152 // This allows us to use 0xffff (ConstantPool::_temp_resolved_klass_index) to indicate
153 // UnresolvedKlass entries that are temporarily created during class redefinition.
154 assert(num_klasses < CPKlassSlot::_temp_resolved_klass_index, "sanity");
155 assert(resolved_klasses() == NULL, "sanity");
156 Array<Klass*>* rk = MetadataFactory::new_writeable_array<Klass*>(loader_data, num_klasses, CHECK);
157 set_resolved_klasses(rk);
158 }
159
160 void ConstantPool::initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS) {
161 int len = length();
162 int num_klasses = 0;
163 for (int i = 1; i <len; i++) {
164 switch (tag_at(i).value()) {
165 case JVM_CONSTANT_ClassIndex:
166 {
167 const int class_index = klass_index_at(i);
168 unresolved_klass_at_put(i, class_index, num_klasses++);
169 }
170 break;
171 #ifndef PRODUCT
172 case JVM_CONSTANT_Class:
173 case JVM_CONSTANT_UnresolvedClass:
174 case JVM_CONSTANT_UnresolvedClassInError:
175 // All of these should have been reverted back to ClassIndex before calling
176 // this function.
177 ShouldNotReachHere();
178 #endif
179 }
180 }
181 allocate_resolved_klasses(loader_data, num_klasses, THREAD);
182 }
183
184 // Anonymous class support:
185 void ConstantPool::klass_at_put(int class_index, int name_index, int resolved_klass_index, Klass* k, Symbol* name) {
186 assert(is_within_bounds(class_index), "index out of bounds");
187 assert(is_within_bounds(name_index), "index out of bounds");
188 assert((resolved_klass_index & 0xffff0000) == 0, "must be");
189 *int_at_addr(class_index) =
190 build_int_from_shorts((jushort)resolved_klass_index, (jushort)name_index);
191
192 symbol_at_put(name_index, name);
193 name->increment_refcount();
194 Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);
195 OrderAccess::release_store_ptr((Klass* volatile *)adr, k);
196
197 // The interpreter assumes when the tag is stored, the klass is resolved
198 // and the Klass* non-NULL, so we need hardware store ordering here.
199 if (k != NULL) {
200 release_tag_at_put(class_index, JVM_CONSTANT_Class);
201 } else {
202 release_tag_at_put(class_index, JVM_CONSTANT_UnresolvedClass);
203 }
204 }
205
206 // Anonymous class support:
207 void ConstantPool::klass_at_put(int class_index, Klass* k) {
208 CPKlassSlot kslot = klass_slot_at(class_index);
209 int resolved_klass_index = kslot.resolved_klass_index();
210 int name_index = kslot.name_index();
211 Symbol* name = symbol_at(name_index);
212 guarantee(name == k->name(), "Invalid class name for anonymous");
213
214 Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);
215 OrderAccess::release_store_ptr((Klass* volatile *)adr, k);
216 }
217
218 // CDS support. Create a new resolved_references array.
219 void ConstantPool::restore_unshareable_info(TRAPS) {
220 assert(is_constantPool(), "ensure C++ vtable is restored");
221 assert(on_stack(), "should always be set for shared constant pools");
222 assert(is_shared(), "should always be set for shared constant pools");
223
224 // Only create the new resolved references array if it hasn't been attempted before
225 if (resolved_references() != NULL) return;
226
227 // restore the C++ vtable from the shared archive
228 restore_vtable();
229
230 if (SystemDictionary::Object_klass_loaded()) {
231 // Recreate the object array and add to ClassLoaderData.
232 int map_length = resolved_reference_length();
233 if (map_length > 0) {
234 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
235 Handle refs_handle (THREAD, (oop)stom); // must handleize.
|