1 /*
2 * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "ci/ciCallSite.hpp"
27 #include "ci/ciInstance.hpp"
28 #include "ci/ciInstanceKlass.hpp"
29 #include "ci/ciMemberName.hpp"
30 #include "ci/ciMethod.hpp"
31 #include "ci/ciMethodData.hpp"
32 #include "ci/ciMethodHandle.hpp"
33 #include "ci/ciMethodType.hpp"
34 #include "ci/ciNullObject.hpp"
35 #include "ci/ciObjArray.hpp"
36 #include "ci/ciObjArrayKlass.hpp"
37 #include "ci/ciObject.hpp"
38 #include "ci/ciObjectFactory.hpp"
39 #include "ci/ciSymbol.hpp"
40 #include "ci/ciTypeArray.hpp"
41 #include "ci/ciTypeArrayKlass.hpp"
42 #include "ci/ciUtilities.hpp"
43 #include "classfile/javaClasses.inline.hpp"
44 #include "classfile/systemDictionary.hpp"
45 #include "gc/shared/collectedHeap.inline.hpp"
46 #include "memory/allocation.inline.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "runtime/fieldType.hpp"
49 #include "utilities/macros.hpp"
50 #if INCLUDE_ALL_GCS
51 # include "gc/g1/g1SATBCardTableModRefBS.hpp"
52 #endif
53
54 // ciObjectFactory
55 //
56 // This class handles requests for the creation of new instances
57 // of ciObject and its subclasses. It contains a caching mechanism
58 // which ensures that for each oop, at most one ciObject is created.
59 // This invariant allows more efficient implementation of ciObject.
60 //
61 // Implementation note: the oop->ciObject mapping is represented as
62 // a table stored in an array. Even though objects are moved
63 // by the garbage collector, the compactor preserves their relative
64 // order; address comparison of oops (in perm space) is safe so long
65 // as we prohibit GC during our comparisons. We currently use binary
66 // search to find the oop in the table, and inserting a new oop
67 // into the table may be costly. If this cost ends up being
68 // problematic the underlying data structure can be switched to some
69 // sort of balanced binary tree.
70
71 GrowableArray<ciMetadata*>* ciObjectFactory::_shared_ci_metadata = NULL;
72 ciSymbol* ciObjectFactory::_shared_ci_symbols[vmSymbols::SID_LIMIT];
73 int ciObjectFactory::_shared_ident_limit = 0;
74 volatile bool ciObjectFactory::_initialized = false;
75
76
77 // ------------------------------------------------------------------
78 // ciObjectFactory::ciObjectFactory
79 ciObjectFactory::ciObjectFactory(Arena* arena,
80 int expected_size) {
81
82 for (int i = 0; i < NON_PERM_BUCKETS; i++) {
83 _non_perm_bucket[i] = NULL;
84 }
85 _non_perm_count = 0;
86
87 _next_ident = _shared_ident_limit;
88 _arena = arena;
89 _ci_metadata = new (arena) GrowableArray<ciMetadata*>(arena, expected_size, 0, NULL);
90
91 // If the shared ci objects exist append them to this factory's objects
92
93 if (_shared_ci_metadata != NULL) {
94 _ci_metadata->appendAll(_shared_ci_metadata);
95 }
96
97 _unloaded_methods = new (arena) GrowableArray<ciMethod*>(arena, 4, 0, NULL);
98 _unloaded_klasses = new (arena) GrowableArray<ciKlass*>(arena, 8, 0, NULL);
99 _unloaded_instances = new (arena) GrowableArray<ciInstance*>(arena, 4, 0, NULL);
100 _return_addresses =
101 new (arena) GrowableArray<ciReturnAddress*>(arena, 8, 0, NULL);
102
103 _symbols = new (arena) GrowableArray<ciSymbol*>(arena, 100, 0, NULL);
104 }
105
106 // ------------------------------------------------------------------
107 // ciObjectFactory::ciObjectFactory
108 void ciObjectFactory::initialize() {
109 ASSERT_IN_VM;
110 JavaThread* thread = JavaThread::current();
111 HandleMark handle_mark(thread);
112
113 // This Arena is long lived and exists in the resource mark of the
114 // compiler thread that initializes the initial ciObjectFactory which
115 // creates the shared ciObjects that all later ciObjectFactories use.
116 Arena* arena = new (mtCompiler) Arena(mtCompiler);
117 ciEnv initial(arena);
118 ciEnv* env = ciEnv::current();
119 env->_factory->init_shared_objects();
120
121 _initialized = true;
122
123 }
124
125 void ciObjectFactory::init_shared_objects() {
126
127 _next_ident = 1; // start numbering CI objects at 1
128
129 {
130 // Create the shared symbols, but not in _shared_ci_metadata.
131 int i;
132 for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) {
133 Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i);
134 assert(vmSymbols::find_sid(vmsym) == i, "1-1 mapping");
135 ciSymbol* sym = new (_arena) ciSymbol(vmsym, (vmSymbols::SID) i);
136 init_ident_of(sym);
137 _shared_ci_symbols[i] = sym;
138 }
139 #ifdef ASSERT
140 for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) {
141 Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i);
142 ciSymbol* sym = vm_symbol_at((vmSymbols::SID) i);
143 assert(sym->get_symbol() == vmsym, "oop must match");
144 }
145 assert(ciSymbol::void_class_signature()->get_symbol() == vmSymbols::void_class_signature(), "spot check");
146 #endif
147 }
148
149 _ci_metadata = new (_arena) GrowableArray<ciMetadata*>(_arena, 64, 0, NULL);
150
151 for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) {
152 BasicType t = (BasicType)i;
153 if (type2name(t) != NULL && t != T_OBJECT && t != T_ARRAY && t != T_NARROWOOP && t != T_NARROWKLASS) {
154 ciType::_basic_types[t] = new (_arena) ciType(t);
155 init_ident_of(ciType::_basic_types[t]);
156 }
157 }
158
159 ciEnv::_null_object_instance = new (_arena) ciNullObject();
160 init_ident_of(ciEnv::_null_object_instance);
161
162 #define WK_KLASS_DEFN(name, ignore_s, opt) \
163 if (SystemDictionary::name() != NULL) \
164 ciEnv::_##name = get_metadata(SystemDictionary::name())->as_instance_klass();
165
166 WK_KLASSES_DO(WK_KLASS_DEFN)
167 #undef WK_KLASS_DEFN
168
169 for (int len = -1; len != _ci_metadata->length(); ) {
170 len = _ci_metadata->length();
171 for (int i2 = 0; i2 < len; i2++) {
172 ciMetadata* obj = _ci_metadata->at(i2);
173 assert (obj->is_metadata(), "what else would it be?");
174 if (obj->is_loaded() && obj->is_instance_klass()) {
175 obj->as_instance_klass()->compute_nonstatic_fields();
176 }
177 }
178 }
179
180 ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol());
181 // Create dummy InstanceKlass and ObjArrayKlass object and assign them idents
182 ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL);
183 init_ident_of(ciEnv::_unloaded_ciinstance_klass);
184 ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1);
185 init_ident_of(ciEnv::_unloaded_ciobjarrayklass);
186 assert(ciEnv::_unloaded_ciobjarrayklass->is_obj_array_klass(), "just checking");
187
188 get_metadata(Universe::boolArrayKlassObj());
189 get_metadata(Universe::charArrayKlassObj());
190 get_metadata(Universe::singleArrayKlassObj());
191 get_metadata(Universe::doubleArrayKlassObj());
192 get_metadata(Universe::byteArrayKlassObj());
193 get_metadata(Universe::shortArrayKlassObj());
194 get_metadata(Universe::intArrayKlassObj());
195 get_metadata(Universe::longArrayKlassObj());
196
197
198
199 assert(_non_perm_count == 0, "no shared non-perm objects");
200
201 // The shared_ident_limit is the first ident number that will
202 // be used for non-shared objects. That is, numbers less than
203 // this limit are permanently assigned to shared CI objects,
204 // while the higher numbers are recycled afresh by each new ciEnv.
205
206 _shared_ident_limit = _next_ident;
207 _shared_ci_metadata = _ci_metadata;
208 }
209
210
211 ciSymbol* ciObjectFactory::get_symbol(Symbol* key) {
212 vmSymbols::SID sid = vmSymbols::find_sid(key);
213 if (sid != vmSymbols::NO_SID) {
214 // do not pollute the main cache with it
215 return vm_symbol_at(sid);
216 }
217
218 assert(vmSymbols::find_sid(key) == vmSymbols::NO_SID, "");
219 ciSymbol* s = new (arena()) ciSymbol(key, vmSymbols::NO_SID);
220 _symbols->push(s);
221 return s;
222 }
223
224 // Decrement the refcount when done on symbols referenced by this compilation.
225 void ciObjectFactory::remove_symbols() {
226 for (int i = 0; i < _symbols->length(); i++) {
227 ciSymbol* s = _symbols->at(i);
228 s->get_symbol()->decrement_refcount();
229 }
230 // Since _symbols is resource allocated we're not allowed to delete it
231 // but it'll go away just the same.
232 }
233
234 // ------------------------------------------------------------------
235 // ciObjectFactory::get
236 //
237 // Get the ciObject corresponding to some oop. If the ciObject has
238 // already been created, it is returned. Otherwise, a new ciObject
239 // is created.
240 ciObject* ciObjectFactory::get(oop key) {
241 ASSERT_IN_VM;
242
243 assert(Universe::heap()->is_in_reserved(key), "must be");
244
245 // In Shenandoah we need to make sure that nobody forwards the key elsewhere
246 // under our hood.
247 key = oopDesc::bs()->write_barrier(key);
248
249 NonPermObject* &bucket = find_non_perm(key);
250 if (bucket != NULL) {
251 return bucket->object();
252 }
253
254 // The ciObject does not yet exist. Create it and insert it
255 // into the cache.
256 Handle keyHandle(key);
257 ciObject* new_object = create_new_object(keyHandle());
258 assert(keyHandle() == new_object->get_oop(), "must be properly recorded");
259 init_ident_of(new_object);
260 assert(Universe::heap()->is_in_reserved(new_object->get_oop()), "must be");
261
262 // Not a perm-space object.
263 insert_non_perm(bucket, keyHandle(), new_object);
264 return new_object;
265 }
266
267 // ------------------------------------------------------------------
268 // ciObjectFactory::get_metadata
269 //
270 // Get the ciMetadata corresponding to some Metadata. If the ciMetadata has
271 // already been created, it is returned. Otherwise, a new ciMetadata
272 // is created.
273 ciMetadata* ciObjectFactory::get_metadata(Metadata* key) {
274 ASSERT_IN_VM;
275
276 #ifdef ASSERT
277 if (CIObjectFactoryVerify) {
278 Metadata* last = NULL;
279 for (int j = 0; j< _ci_metadata->length(); j++) {
280 Metadata* o = _ci_metadata->at(j)->constant_encoding();
281 assert(last < o, "out of order");
282 last = o;
283 }
284 }
285 #endif // ASSERT
286 int len = _ci_metadata->length();
287 int index = find(key, _ci_metadata);
288 #ifdef ASSERT
289 if (CIObjectFactoryVerify) {
290 for (int i=0; i<_ci_metadata->length(); i++) {
291 if (_ci_metadata->at(i)->constant_encoding() == key) {
292 assert(index == i, " bad lookup");
293 }
294 }
295 }
296 #endif
297 if (!is_found_at(index, key, _ci_metadata)) {
298 // The ciMetadata does not yet exist. Create it and insert it
299 // into the cache.
300 ciMetadata* new_object = create_new_metadata(key);
301 init_ident_of(new_object);
302 assert(new_object->is_metadata(), "must be");
303
304 if (len != _ci_metadata->length()) {
305 // creating the new object has recursively entered new objects
306 // into the table. We need to recompute our index.
307 index = find(key, _ci_metadata);
308 }
309 assert(!is_found_at(index, key, _ci_metadata), "no double insert");
310 insert(index, new_object, _ci_metadata);
311 return new_object;
312 }
313 return _ci_metadata->at(index)->as_metadata();
314 }
315
316 // ------------------------------------------------------------------
317 // ciObjectFactory::create_new_object
318 //
319 // Create a new ciObject from an oop.
320 //
321 // Implementation note: this functionality could be virtual behavior
322 // of the oop itself. For now, we explicitly marshal the object.
323 ciObject* ciObjectFactory::create_new_object(oop o) {
324 EXCEPTION_CONTEXT;
325
326 if (o->is_instance()) {
327 instanceHandle h_i(THREAD, (instanceOop)o);
328 if (java_lang_invoke_CallSite::is_instance(o))
329 return new (arena()) ciCallSite(h_i);
330 else if (java_lang_invoke_MemberName::is_instance(o))
331 return new (arena()) ciMemberName(h_i);
332 else if (java_lang_invoke_MethodHandle::is_instance(o))
333 return new (arena()) ciMethodHandle(h_i);
334 else if (java_lang_invoke_MethodType::is_instance(o))
335 return new (arena()) ciMethodType(h_i);
336 else
337 return new (arena()) ciInstance(h_i);
338 } else if (o->is_objArray()) {
339 objArrayHandle h_oa(THREAD, (objArrayOop)o);
340 return new (arena()) ciObjArray(h_oa);
341 } else if (o->is_typeArray()) {
342 typeArrayHandle h_ta(THREAD, (typeArrayOop)o);
343 return new (arena()) ciTypeArray(h_ta);
344 }
345
346 // The oop is of some type not supported by the compiler interface.
347 ShouldNotReachHere();
348 return NULL;
349 }
350
351 // ------------------------------------------------------------------
352 // ciObjectFactory::create_new_metadata
353 //
354 // Create a new ciMetadata from a Metadata*.
355 //
356 // Implementation note: in order to keep Metadata live, an auxiliary ciObject
357 // is used, which points to it's holder.
358 ciMetadata* ciObjectFactory::create_new_metadata(Metadata* o) {
359 EXCEPTION_CONTEXT;
360
361 // Hold metadata from unloading by keeping it's holder alive.
362 if (_initialized && o->is_klass()) {
363 Klass* holder = ((Klass*)o);
364 if (holder->oop_is_instance() && InstanceKlass::cast(holder)->is_anonymous()) {
365 // Though ciInstanceKlass records class loader oop, it's not enough to keep
366 // VM anonymous classes alive (loader == NULL). Klass holder should be used instead.
367 // It is enough to record a ciObject, since cached elements are never removed
368 // during ciObjectFactory lifetime. ciObjectFactory itself is created for
369 // every compilation and lives for the whole duration of the compilation.
370 ciObject* h = get(holder->klass_holder());
371 }
372 }
373
374 if (o->is_klass()) {
375 KlassHandle h_k(THREAD, (Klass*)o);
376 Klass* k = (Klass*)o;
377 if (k->oop_is_instance()) {
378 return new (arena()) ciInstanceKlass(h_k);
379 } else if (k->oop_is_objArray()) {
380 return new (arena()) ciObjArrayKlass(h_k);
381 } else if (k->oop_is_typeArray()) {
382 return new (arena()) ciTypeArrayKlass(h_k);
383 }
384 } else if (o->is_method()) {
385 methodHandle h_m(THREAD, (Method*)o);
386 ciEnv *env = CURRENT_THREAD_ENV;
387 ciInstanceKlass* holder = env->get_instance_klass(h_m()->method_holder());
388 return new (arena()) ciMethod(h_m, holder);
389 } else if (o->is_methodData()) {
390 // Hold methodHandle alive - might not be necessary ???
391 methodHandle h_m(THREAD, ((MethodData*)o)->method());
392 return new (arena()) ciMethodData((MethodData*)o);
393 }
394
395 // The Metadata* is of some type not supported by the compiler interface.
396 ShouldNotReachHere();
397 return NULL;
398 }
399
400 // ------------------------------------------------------------------
401 // ciObjectFactory::ensure_metadata_alive
402 //
403 // Ensure that the metadata wrapped by the ciMetadata is kept alive by GC.
404 // This is primarily useful for metadata which is considered as weak roots
405 // by the GC but need to be strong roots if reachable from a current compilation.
406 //
407 void ciObjectFactory::ensure_metadata_alive(ciMetadata* m) {
408 ASSERT_IN_VM; // We're handling raw oops here.
409
410 #if INCLUDE_ALL_GCS
411 if (!UseG1GC) {
412 return;
413 }
414 Klass* metadata_owner_klass;
415 if (m->is_klass()) {
416 metadata_owner_klass = m->as_klass()->get_Klass();
417 } else if (m->is_method()) {
418 metadata_owner_klass = m->as_method()->get_Method()->constants()->pool_holder();
419 } else {
420 fatal("Not implemented for other types of metadata");
421 }
422
423 oop metadata_holder = metadata_owner_klass->klass_holder();
424 if (metadata_holder != NULL) {
425 G1SATBCardTableModRefBS::enqueue(metadata_holder);
426 }
427
428 #endif
429 }
430
431 //------------------------------------------------------------------
432 // ciObjectFactory::get_unloaded_method
433 //
434 // Get the ciMethod representing an unloaded/unfound method.
435 //
436 // Implementation note: unloaded methods are currently stored in
437 // an unordered array, requiring a linear-time lookup for each
438 // unloaded method. This may need to change.
439 ciMethod* ciObjectFactory::get_unloaded_method(ciInstanceKlass* holder,
440 ciSymbol* name,
441 ciSymbol* signature,
442 ciInstanceKlass* accessor) {
443 ciSignature* that = NULL;
444 for (int i = 0; i < _unloaded_methods->length(); i++) {
445 ciMethod* entry = _unloaded_methods->at(i);
446 if (entry->holder()->equals(holder) &&
447 entry->name()->equals(name) &&
448 entry->signature()->as_symbol()->equals(signature)) {
449 // Short-circuit slow resolve.
450 if (entry->signature()->accessing_klass() == accessor) {
451 // We've found a match.
452 return entry;
453 } else {
454 // Lazily create ciSignature
455 if (that == NULL) that = new (arena()) ciSignature(accessor, constantPoolHandle(), signature);
456 if (entry->signature()->equals(that)) {
457 // We've found a match.
458 return entry;
459 }
460 }
461 }
462 }
463
464 // This is a new unloaded method. Create it and stick it in
465 // the cache.
466 ciMethod* new_method = new (arena()) ciMethod(holder, name, signature, accessor);
467
468 init_ident_of(new_method);
469 _unloaded_methods->append(new_method);
470
471 return new_method;
472 }
473
474 //------------------------------------------------------------------
475 // ciObjectFactory::get_unloaded_klass
476 //
477 // Get a ciKlass representing an unloaded klass.
478 //
479 // Implementation note: unloaded klasses are currently stored in
480 // an unordered array, requiring a linear-time lookup for each
481 // unloaded klass. This may need to change.
482 ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass,
483 ciSymbol* name,
484 bool create_if_not_found) {
485 EXCEPTION_CONTEXT;
486 oop loader = NULL;
487 oop domain = NULL;
488 if (accessing_klass != NULL) {
489 loader = accessing_klass->loader();
490 domain = accessing_klass->protection_domain();
491 }
492 for (int i=0; i<_unloaded_klasses->length(); i++) {
493 ciKlass* entry = _unloaded_klasses->at(i);
494 if (entry->name()->equals(name) &&
495 entry->loader() == loader &&
496 entry->protection_domain() == domain) {
497 // We've found a match.
498 return entry;
499 }
500 }
501
502 if (!create_if_not_found)
503 return NULL;
504
505 // This is a new unloaded klass. Create it and stick it in
506 // the cache.
507 ciKlass* new_klass = NULL;
508
509 // Two cases: this is an unloaded ObjArrayKlass or an
510 // unloaded InstanceKlass. Deal with both.
511 if (name->byte_at(0) == '[') {
512 // Decompose the name.'
513 FieldArrayInfo fd;
514 BasicType element_type = FieldType::get_array_info(name->get_symbol(),
515 fd, THREAD);
516 if (HAS_PENDING_EXCEPTION) {
517 CLEAR_PENDING_EXCEPTION;
518 CURRENT_THREAD_ENV->record_out_of_memory_failure();
519 return ciEnv::_unloaded_ciobjarrayklass;
520 }
521 int dimension = fd.dimension();
522 assert(element_type != T_ARRAY, "unsuccessful decomposition");
523 ciKlass* element_klass = NULL;
524 if (element_type == T_OBJECT) {
525 ciEnv *env = CURRENT_THREAD_ENV;
526 ciSymbol* ci_name = env->get_symbol(fd.object_key());
527 element_klass =
528 env->get_klass_by_name(accessing_klass, ci_name, false)->as_instance_klass();
529 } else {
530 assert(dimension > 1, "one dimensional type arrays are always loaded.");
531
532 // The type array itself takes care of one of the dimensions.
533 dimension--;
534
535 // The element klass is a TypeArrayKlass.
536 element_klass = ciTypeArrayKlass::make(element_type);
537 }
538 new_klass = new (arena()) ciObjArrayKlass(name, element_klass, dimension);
539 } else {
540 jobject loader_handle = NULL;
541 jobject domain_handle = NULL;
542 if (accessing_klass != NULL) {
543 loader_handle = accessing_klass->loader_handle();
544 domain_handle = accessing_klass->protection_domain_handle();
545 }
546 new_klass = new (arena()) ciInstanceKlass(name, loader_handle, domain_handle);
547 }
548 init_ident_of(new_klass);
549 _unloaded_klasses->append(new_klass);
550
551 return new_klass;
552 }
553
554
555 //------------------------------------------------------------------
556 // ciObjectFactory::get_unloaded_instance
557 //
558 // Get a ciInstance representing an as-yet undetermined instance of a given class.
559 //
560 ciInstance* ciObjectFactory::get_unloaded_instance(ciInstanceKlass* instance_klass) {
561 for (int i=0; i<_unloaded_instances->length(); i++) {
562 ciInstance* entry = _unloaded_instances->at(i);
563 if (entry->klass()->equals(instance_klass)) {
564 // We've found a match.
565 return entry;
566 }
567 }
568
569 // This is a new unloaded instance. Create it and stick it in
570 // the cache.
571 ciInstance* new_instance = new (arena()) ciInstance(instance_klass);
572
573 init_ident_of(new_instance);
574 _unloaded_instances->append(new_instance);
575
576 // make sure it looks the way we want:
577 assert(!new_instance->is_loaded(), "");
578 assert(new_instance->klass() == instance_klass, "");
579
580 return new_instance;
581 }
582
583
584 //------------------------------------------------------------------
585 // ciObjectFactory::get_unloaded_klass_mirror
586 //
587 // Get a ciInstance representing an unresolved klass mirror.
588 //
589 // Currently, this ignores the parameters and returns a unique unloaded instance.
590 ciInstance* ciObjectFactory::get_unloaded_klass_mirror(ciKlass* type) {
591 assert(ciEnv::_Class_klass != NULL, "");
592 return get_unloaded_instance(ciEnv::_Class_klass->as_instance_klass());
593 }
594
595 //------------------------------------------------------------------
596 // ciObjectFactory::get_unloaded_method_handle_constant
597 //
598 // Get a ciInstance representing an unresolved method handle constant.
599 //
600 // Currently, this ignores the parameters and returns a unique unloaded instance.
601 ciInstance* ciObjectFactory::get_unloaded_method_handle_constant(ciKlass* holder,
602 ciSymbol* name,
603 ciSymbol* signature,
604 int ref_kind) {
605 if (ciEnv::_MethodHandle_klass == NULL) return NULL;
606 return get_unloaded_instance(ciEnv::_MethodHandle_klass->as_instance_klass());
607 }
608
609 //------------------------------------------------------------------
610 // ciObjectFactory::get_unloaded_method_type_constant
611 //
612 // Get a ciInstance representing an unresolved method type constant.
613 //
614 // Currently, this ignores the parameters and returns a unique unloaded instance.
615 ciInstance* ciObjectFactory::get_unloaded_method_type_constant(ciSymbol* signature) {
616 if (ciEnv::_MethodType_klass == NULL) return NULL;
617 return get_unloaded_instance(ciEnv::_MethodType_klass->as_instance_klass());
618 }
619
620 ciInstance* ciObjectFactory::get_unloaded_object_constant() {
621 if (ciEnv::_Object_klass == NULL) return NULL;
622 return get_unloaded_instance(ciEnv::_Object_klass->as_instance_klass());
623 }
624
625 //------------------------------------------------------------------
626 // ciObjectFactory::get_empty_methodData
627 //
628 // Get the ciMethodData representing the methodData for a method with
629 // none.
630 ciMethodData* ciObjectFactory::get_empty_methodData() {
631 ciMethodData* new_methodData = new (arena()) ciMethodData();
632 init_ident_of(new_methodData);
633 return new_methodData;
634 }
635
636 //------------------------------------------------------------------
637 // ciObjectFactory::get_return_address
638 //
639 // Get a ciReturnAddress for a specified bci.
640 ciReturnAddress* ciObjectFactory::get_return_address(int bci) {
641 for (int i=0; i<_return_addresses->length(); i++) {
642 ciReturnAddress* entry = _return_addresses->at(i);
643 if (entry->bci() == bci) {
644 // We've found a match.
645 return entry;
646 }
647 }
648
649 ciReturnAddress* new_ret_addr = new (arena()) ciReturnAddress(bci);
650 init_ident_of(new_ret_addr);
651 _return_addresses->append(new_ret_addr);
652 return new_ret_addr;
653 }
654
655 // ------------------------------------------------------------------
656 // ciObjectFactory::init_ident_of
657 void ciObjectFactory::init_ident_of(ciBaseObject* obj) {
658 obj->set_ident(_next_ident++);
659 }
660
661 // ------------------------------------------------------------------
662 // ciObjectFactory::find
663 //
664 // Use binary search to find the position of this oop in the cache.
665 // If there is no entry in the cache corresponding to this oop, return
666 // the position at which the oop should be inserted.
667 int ciObjectFactory::find(Metadata* key, GrowableArray<ciMetadata*>* objects) {
668 int min = 0;
669 int max = objects->length()-1;
670
671 // print_contents();
672
673 while (max >= min) {
674 int mid = (max + min) / 2;
675 Metadata* value = objects->at(mid)->constant_encoding();
676 if (value < key) {
677 min = mid + 1;
678 } else if (value > key) {
679 max = mid - 1;
680 } else {
681 return mid;
682 }
683 }
684 return min;
685 }
686
687 // ------------------------------------------------------------------
688 // ciObjectFactory::is_found_at
689 //
690 // Verify that the binary seach found the given key.
691 bool ciObjectFactory::is_found_at(int index, Metadata* key, GrowableArray<ciMetadata*>* objects) {
692 return (index < objects->length() &&
693 objects->at(index)->constant_encoding() == key);
694 }
695
696
697 // ------------------------------------------------------------------
698 // ciObjectFactory::insert
699 //
700 // Insert a ciObject into the table at some index.
701 void ciObjectFactory::insert(int index, ciMetadata* obj, GrowableArray<ciMetadata*>* objects) {
702 int len = objects->length();
703 if (len == index) {
704 objects->append(obj);
705 } else {
706 objects->append(objects->at(len-1));
707 int pos;
708 for (pos = len-2; pos >= index; pos--) {
709 objects->at_put(pos+1,objects->at(pos));
710 }
711 objects->at_put(index, obj);
712 }
713 }
714
715 static ciObjectFactory::NonPermObject* emptyBucket = NULL;
716
717 // ------------------------------------------------------------------
718 // ciObjectFactory::find_non_perm
719 //
720 // Use a small hash table, hashed on the klass of the key.
721 // If there is no entry in the cache corresponding to this oop, return
722 // the null tail of the bucket into which the oop should be inserted.
723 ciObjectFactory::NonPermObject* &ciObjectFactory::find_non_perm(oop key) {
724 assert(Universe::heap()->is_in_reserved(key), "must be");
725 ciMetadata* klass = get_metadata(key->klass());
726 NonPermObject* *bp = &_non_perm_bucket[(unsigned) klass->hash() % NON_PERM_BUCKETS];
727 for (NonPermObject* p; (p = (*bp)) != NULL; bp = &p->next()) {
728 if (is_equal(p, key)) break;
729 }
730 return (*bp);
731 }
732
733
734
735 // ------------------------------------------------------------------
736 // Code for for NonPermObject
737 //
738 inline ciObjectFactory::NonPermObject::NonPermObject(ciObjectFactory::NonPermObject* &bucket, oop key, ciObject* object) {
739 assert(ciObjectFactory::is_initialized(), "");
740 _object = object;
741 _next = bucket;
742 bucket = this;
743 }
744
745
746
747 // ------------------------------------------------------------------
748 // ciObjectFactory::insert_non_perm
749 //
750 // Insert a ciObject into the non-perm table.
751 void ciObjectFactory::insert_non_perm(ciObjectFactory::NonPermObject* &where, oop key, ciObject* obj) {
752 assert(Universe::heap()->is_in_reserved_or_null(key), "must be");
753 assert(&where != &emptyBucket, "must not try to fill empty bucket");
754 NonPermObject* p = new (arena()) NonPermObject(where, key, obj);
755 assert(where == p && is_equal(p, key) && p->object() == obj, "entry must match");
756 assert(find_non_perm(key) == p, "must find the same spot");
757 ++_non_perm_count;
758 }
759
760 // ------------------------------------------------------------------
761 // ciObjectFactory::vm_symbol_at
762 // Get the ciSymbol corresponding to some index in vmSymbols.
763 ciSymbol* ciObjectFactory::vm_symbol_at(int index) {
764 assert(index >= vmSymbols::FIRST_SID && index < vmSymbols::SID_LIMIT, "oob");
765 return _shared_ci_symbols[index];
766 }
767
768 // ------------------------------------------------------------------
769 // ciObjectFactory::metadata_do
770 void ciObjectFactory::metadata_do(void f(Metadata*)) {
771 if (_ci_metadata == NULL) return;
772 for (int j = 0; j< _ci_metadata->length(); j++) {
773 Metadata* o = _ci_metadata->at(j)->constant_encoding();
774 f(o);
775 }
776 }
777
778 // ------------------------------------------------------------------
779 // ciObjectFactory::print_contents_impl
780 void ciObjectFactory::print_contents_impl() {
781 int len = _ci_metadata->length();
782 tty->print_cr("ciObjectFactory (%d) meta data contents:", len);
783 for (int i=0; i<len; i++) {
784 _ci_metadata->at(i)->print();
785 tty->cr();
786 }
787 }
788
789 // ------------------------------------------------------------------
790 // ciObjectFactory::print_contents
791 void ciObjectFactory::print_contents() {
792 print();
793 tty->cr();
794 GUARDED_VM_ENTRY(print_contents_impl();)
795 }
796
797 // ------------------------------------------------------------------
798 // ciObjectFactory::print
799 //
800 // Print debugging information about the object factory
801 void ciObjectFactory::print() {
802 tty->print("<ciObjectFactory oops=%d metadata=%d unloaded_methods=%d unloaded_instances=%d unloaded_klasses=%d>",
803 _non_perm_count, _ci_metadata->length(), _unloaded_methods->length(),
804 _unloaded_instances->length(),
805 _unloaded_klasses->length());
806 }