1 /*
  2  * Copyright (c) 1999, 2022, 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/ciField.hpp"
 27 #include "ci/ciInlineKlass.hpp"
 28 #include "ci/ciInstance.hpp"
 29 #include "ci/ciInstanceKlass.hpp"
 30 #include "ci/ciUtilities.inline.hpp"
 31 #include "classfile/javaClasses.hpp"
 32 #include "classfile/systemDictionary.hpp"
 33 #include "classfile/vmClasses.hpp"
 34 #include "memory/allocation.hpp"
 35 #include "memory/allocation.inline.hpp"
 36 #include "memory/resourceArea.hpp"
 37 #include "oops/instanceKlass.inline.hpp"
 38 #include "oops/klass.inline.hpp"
 39 #include "oops/oop.inline.hpp"
 40 #include "oops/fieldStreams.inline.hpp"
 41 #include "oops/inlineKlass.inline.hpp"
 42 #include "runtime/fieldDescriptor.inline.hpp"
 43 #include "runtime/handles.inline.hpp"
 44 #include "runtime/jniHandles.inline.hpp"
 45 
 46 // ciInstanceKlass
 47 //
 48 // This class represents a Klass* in the HotSpot virtual machine
 49 // whose Klass part in an InstanceKlass.
 50 
 51 
 52 // ------------------------------------------------------------------
 53 // ciInstanceKlass::ciInstanceKlass
 54 //
 55 // Loaded instance klass.
 56 ciInstanceKlass::ciInstanceKlass(Klass* k) :
 57   ciKlass(k)
 58 {
 59   assert(get_Klass()->is_instance_klass(), "wrong type");
 60   assert(get_instanceKlass()->is_loaded(), "must be at least loaded");
 61   InstanceKlass* ik = get_instanceKlass();
 62 
 63   AccessFlags access_flags = ik->access_flags();
 64   _flags = ciFlags(access_flags);
 65   _has_finalizer = access_flags.has_finalizer();
 66   _has_subklass = flags().is_final() ? subklass_false : subklass_unknown;
 67   _init_state = ik->init_state();
 68   _has_nonstatic_fields = ik->has_nonstatic_fields();
 69   _has_nonstatic_concrete_methods = ik->has_nonstatic_concrete_methods();
 70   _is_hidden = ik->is_hidden();
 71   _is_record = ik->is_record();
 72   _nonstatic_fields = NULL; // initialized lazily by compute_nonstatic_fields:
 73   _has_injected_fields = -1;
 74   _implementor = NULL; // we will fill these lazily
 75 
 76   // Ensure that the metadata wrapped by the ciMetadata is kept alive by GC.
 77   // This is primarily useful for metadata which is considered as weak roots
 78   // by the GC but need to be strong roots if reachable from a current compilation.
 79   // InstanceKlass are created for both weak and strong metadata.  Ensuring this metadata
 80   // alive covers the cases where there are weak roots without performance cost.
 81   oop holder = ik->klass_holder();
 82   if (ik->class_loader_data()->has_class_mirror_holder()) {
 83     // Though ciInstanceKlass records class loader oop, it's not enough to keep
 84     // non-strong hidden classes alive (loader == NULL). Klass holder should
 85     // be used instead. It is enough to record a ciObject, since cached elements are never removed
 86     // during ciObjectFactory lifetime. ciObjectFactory itself is created for
 87     // every compilation and lives for the whole duration of the compilation.
 88     assert(holder != NULL, "holder of hidden class is the mirror which is never null");
 89     (void)CURRENT_ENV->get_object(holder);
 90   }
 91 
 92   JavaThread *thread = JavaThread::current();
 93   if (ciObjectFactory::is_initialized()) {
 94     _loader = JNIHandles::make_local(thread, ik->class_loader());
 95     _protection_domain = JNIHandles::make_local(thread,
 96                                                 ik->protection_domain());
 97     _is_shared = false;
 98   } else {
 99     Handle h_loader(thread, ik->class_loader());
100     Handle h_protection_domain(thread, ik->protection_domain());
101     _loader = JNIHandles::make_global(h_loader);
102     _protection_domain = JNIHandles::make_global(h_protection_domain);
103     _is_shared = true;
104   }
105 
106   _has_trusted_loader = compute_has_trusted_loader();
107 
108   // Lazy fields get filled in only upon request.
109   _super  = NULL;
110   _java_mirror = NULL;
111 
112   if (is_shared()) {
113     if (k != vmClasses::Object_klass()) {
114       super();
115     }
116     //compute_nonstatic_fields();  // done outside of constructor
117   }
118 
119   _field_cache = NULL;
120 }
121 
122 // Version for unloaded classes:
123 ciInstanceKlass::ciInstanceKlass(ciSymbol* name,
124                                  jobject loader, jobject protection_domain,
125                                  BasicType bt)
126   : ciKlass(name, bt)
127 {
128   assert(name->char_at(0) != JVM_SIGNATURE_ARRAY, "not an instance klass");
129   _init_state = (InstanceKlass::ClassState)0;
130   _has_nonstatic_fields = false;
131   _nonstatic_fields = NULL;            // initialized lazily by compute_nonstatic_fields
132   _has_injected_fields = -1;
133   _is_hidden = false;
134   _is_record = false;
135   _loader = loader;
136   _protection_domain = protection_domain;
137   _is_shared = false;
138   _super = NULL;
139   _java_mirror = NULL;
140   _field_cache = NULL;
141   _has_trusted_loader = compute_has_trusted_loader();
142 }
143 
144 
145 
146 // ------------------------------------------------------------------
147 // ciInstanceKlass::compute_shared_is_initialized
148 void ciInstanceKlass::compute_shared_init_state() {
149   GUARDED_VM_ENTRY(
150     InstanceKlass* ik = get_instanceKlass();
151     _init_state = ik->init_state();
152   )
153 }
154 
155 // ------------------------------------------------------------------
156 // ciInstanceKlass::compute_shared_has_subklass
157 bool ciInstanceKlass::compute_shared_has_subklass() {
158   GUARDED_VM_ENTRY(
159     InstanceKlass* ik = get_instanceKlass();
160     _has_subklass = ik->subklass() != NULL ? subklass_true : subklass_false;
161     return _has_subklass == subklass_true;
162   )
163 }
164 
165 // ------------------------------------------------------------------
166 // ciInstanceKlass::loader
167 oop ciInstanceKlass::loader() {
168   ASSERT_IN_VM;
169   return JNIHandles::resolve(_loader);
170 }
171 
172 // ------------------------------------------------------------------
173 // ciInstanceKlass::loader_handle
174 jobject ciInstanceKlass::loader_handle() {
175   return _loader;
176 }
177 
178 // ------------------------------------------------------------------
179 // ciInstanceKlass::protection_domain
180 oop ciInstanceKlass::protection_domain() {
181   ASSERT_IN_VM;
182   return JNIHandles::resolve(_protection_domain);
183 }
184 
185 // ------------------------------------------------------------------
186 // ciInstanceKlass::protection_domain_handle
187 jobject ciInstanceKlass::protection_domain_handle() {
188   return _protection_domain;
189 }
190 
191 // ------------------------------------------------------------------
192 // ciInstanceKlass::field_cache
193 //
194 // Get the field cache associated with this klass.
195 ciConstantPoolCache* ciInstanceKlass::field_cache() {
196   if (is_shared()) {
197     return NULL;
198   }
199   if (_field_cache == NULL) {
200     assert(!is_java_lang_Object(), "Object has no fields");
201     Arena* arena = CURRENT_ENV->arena();
202     _field_cache = new (arena) ciConstantPoolCache(arena, 5);
203   }
204   return _field_cache;
205 }
206 
207 // ------------------------------------------------------------------
208 // ciInstanceKlass::get_canonical_holder
209 //
210 ciInstanceKlass* ciInstanceKlass::get_canonical_holder(int offset) {
211   #ifdef ASSERT
212   if (!(offset >= 0 && offset < layout_helper_size_in_bytes())) {
213     tty->print("*** get_canonical_holder(%d) on ", offset);
214     this->print();
215     tty->print_cr(" ***");
216   };
217   assert(offset >= 0 && offset < layout_helper_size_in_bytes(), "offset must be tame");
218   #endif
219 
220   if (offset < instanceOopDesc::base_offset_in_bytes()) {
221     // All header offsets belong properly to java/lang/Object.
222     return CURRENT_ENV->Object_klass();
223   }
224 
225   ciInstanceKlass* self = this;
226   assert(self->is_loaded(), "must be loaded to access field info");
227   ciField* field = self->get_field_by_offset(offset, false);
228   if (field != NULL) {
229     return field->holder();
230   } else {
231     for (;;) {
232       assert(self->is_loaded(), "must be loaded to have size");
233       ciInstanceKlass* super = self->super();
234       if (super == NULL ||
235           super->nof_nonstatic_fields() == 0 ||
236           super->layout_helper_size_in_bytes() <= offset) {
237         return self;
238       } else {
239         self = super;  // return super->get_canonical_holder(offset)
240       }
241     }
242   }
243 }
244 
245 // ------------------------------------------------------------------
246 // ciInstanceKlass::is_java_lang_Object
247 //
248 // Is this klass java.lang.Object?
249 bool ciInstanceKlass::is_java_lang_Object() const {
250   return equals(CURRENT_ENV->Object_klass());
251 }
252 
253 // ------------------------------------------------------------------
254 // ciInstanceKlass::uses_default_loader
255 bool ciInstanceKlass::uses_default_loader() const {
256   // Note:  We do not need to resolve the handle or enter the VM
257   // in order to test null-ness.
258   return _loader == NULL;
259 }
260 
261 // ------------------------------------------------------------------
262 
263 /**
264  * Return basic type of boxed value for box klass or T_OBJECT if not.
265  */
266 BasicType ciInstanceKlass::box_klass_type() const {
267   if (uses_default_loader() && is_loaded()) {
268     return vmClasses::box_klass_type(get_Klass());
269   } else {
270     return T_OBJECT;
271   }
272 }
273 
274 /**
275  * Is this boxing klass?
276  */
277 bool ciInstanceKlass::is_box_klass() const {
278   return is_java_primitive(box_klass_type());
279 }
280 
281 /**
282  *  Is this boxed value offset?
283  */
284 bool ciInstanceKlass::is_boxed_value_offset(int offset) const {
285   BasicType bt = box_klass_type();
286   return is_java_primitive(bt) &&
287          (offset == java_lang_boxing_object::value_offset(bt));
288 }
289 
290 // ------------------------------------------------------------------
291 // ciInstanceKlass::is_in_package
292 //
293 // Is this klass in the given package?
294 bool ciInstanceKlass::is_in_package(const char* packagename, int len) {
295   // To avoid class loader mischief, this test always rejects application classes.
296   if (!uses_default_loader())
297     return false;
298   GUARDED_VM_ENTRY(
299     return is_in_package_impl(packagename, len);
300   )
301 }
302 
303 bool ciInstanceKlass::is_in_package_impl(const char* packagename, int len) {
304   ASSERT_IN_VM;
305 
306   // If packagename contains trailing '/' exclude it from the
307   // prefix-test since we test for it explicitly.
308   if (packagename[len - 1] == '/')
309     len--;
310 
311   if (!name()->starts_with(packagename, len))
312     return false;
313 
314   // Test if the class name is something like "java/lang".
315   if ((len + 1) > name()->utf8_length())
316     return false;
317 
318   // Test for trailing '/'
319   if (name()->char_at(len) != '/')
320     return false;
321 
322   // Make sure it's not actually in a subpackage:
323   if (name()->index_of_at(len+1, "/", 1) >= 0)
324     return false;
325 
326   return true;
327 }
328 
329 // ------------------------------------------------------------------
330 // ciInstanceKlass::print_impl
331 //
332 // Implementation of the print method.
333 void ciInstanceKlass::print_impl(outputStream* st) {
334   ciKlass::print_impl(st);
335   GUARDED_VM_ENTRY(st->print(" loader=" INTPTR_FORMAT, p2i(loader()));)
336   if (is_loaded()) {
337     st->print(" initialized=%s finalized=%s subklass=%s size=%d flags=",
338               bool_to_str(is_initialized()),
339               bool_to_str(has_finalizer()),
340               bool_to_str(has_subklass()),
341               layout_helper());
342 
343     _flags.print_klass_flags(st);
344 
345     if (_super) {
346       st->print(" super=");
347       _super->print_name_on(st);
348     }
349     if (_java_mirror) {
350       st->print(" mirror=PRESENT");
351     }
352   }
353 }
354 
355 // ------------------------------------------------------------------
356 // ciInstanceKlass::super
357 //
358 // Get the superklass of this klass.
359 ciInstanceKlass* ciInstanceKlass::super() {
360   assert(is_loaded(), "must be loaded");
361   if (_super == NULL && !is_java_lang_Object()) {
362     GUARDED_VM_ENTRY(
363       Klass* super_klass = get_instanceKlass()->super();
364       _super = CURRENT_ENV->get_instance_klass(super_klass);
365     )
366   }
367   return _super;
368 }
369 
370 // ------------------------------------------------------------------
371 // ciInstanceKlass::java_mirror
372 //
373 // Get the instance of java.lang.Class corresponding to this klass.
374 // Cache it on this->_java_mirror.
375 ciInstance* ciInstanceKlass::java_mirror() {
376   if (is_shared()) {
377     return ciKlass::java_mirror();
378   }
379   if (_java_mirror == NULL) {
380     _java_mirror = ciKlass::java_mirror();
381   }
382   return _java_mirror;
383 }
384 
385 // ------------------------------------------------------------------
386 // ciInstanceKlass::unique_concrete_subklass
387 ciInstanceKlass* ciInstanceKlass::unique_concrete_subklass() {
388   if (!is_loaded())     return NULL; // No change if class is not loaded
389   if (!is_abstract())   return NULL; // Only applies to abstract classes.
390   if (!has_subklass())  return NULL; // Must have at least one subklass.
391   VM_ENTRY_MARK;
392   InstanceKlass* ik = get_instanceKlass();
393   Klass* up = ik->up_cast_abstract();
394   assert(up->is_instance_klass(), "must be InstanceKlass");
395   if (ik == up) {
396     return NULL;
397   }
398   return CURRENT_THREAD_ENV->get_instance_klass(up);
399 }
400 
401 // ------------------------------------------------------------------
402 // ciInstanceKlass::has_finalizable_subclass
403 bool ciInstanceKlass::has_finalizable_subclass() {
404   if (!is_loaded())     return true;
405   VM_ENTRY_MARK;
406   return Dependencies::find_finalizable_subclass(get_instanceKlass()) != NULL;
407 }
408 
409 // ------------------------------------------------------------------
410 // ciInstanceKlass::contains_field_offset
411 bool ciInstanceKlass::contains_field_offset(int offset) {
412   VM_ENTRY_MARK;
413   return get_instanceKlass()->contains_field_offset(offset);
414 }
415 
416 // ------------------------------------------------------------------
417 // ciInstanceKlass::get_field_by_offset
418 ciField* ciInstanceKlass::get_field_by_offset(int field_offset, bool is_static) {
419   if (!is_static) {
420     for (int i = 0, len = nof_nonstatic_fields(); i < len; i++) {
421       ciField* field = _nonstatic_fields->at(i);
422       int  field_off = field->offset_in_bytes();
423       if (field_off == field_offset)
424         return field;
425       if (field_off > field_offset)
426         break;
427       // could do binary search or check bins, but probably not worth it
428     }
429     return NULL;
430   }
431   VM_ENTRY_MARK;
432   InstanceKlass* k = get_instanceKlass();
433   fieldDescriptor fd;
434   if (!k->find_field_from_offset(field_offset, is_static, &fd)) {
435     return NULL;
436   }
437   ciField* field = new (CURRENT_THREAD_ENV->arena()) ciField(&fd);
438   return field;
439 }
440 
441 ciField* ciInstanceKlass::get_non_flattened_field_by_offset(int field_offset) {
442   if (super() != NULL && super()->has_nonstatic_fields()) {
443     ciField* f = super()->get_non_flattened_field_by_offset(field_offset);
444     if (f != NULL) {
445       return f;
446     }
447   }
448 
449   VM_ENTRY_MARK;
450   InstanceKlass* k = get_instanceKlass();
451   Arena* arena = CURRENT_ENV->arena();
452   for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
453     if (fs.access_flags().is_static())  continue;
454     fieldDescriptor& fd = fs.field_descriptor();
455     if (fd.offset() == field_offset) {
456       ciField* f = new (arena) ciField(&fd);
457       return f;
458     }
459   }
460 
461   return NULL;
462 }
463 
464 // ------------------------------------------------------------------
465 // ciInstanceKlass::get_field_by_name
466 ciField* ciInstanceKlass::get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static) {
467   VM_ENTRY_MARK;
468   InstanceKlass* k = get_instanceKlass();
469   fieldDescriptor fd;
470   Klass* def = k->find_field(name->get_symbol(), signature->get_symbol(), is_static, &fd);
471   if (def == NULL) {
472     return NULL;
473   }
474   ciField* field = new (CURRENT_THREAD_ENV->arena()) ciField(&fd);
475   return field;
476 }
477 
478 
479 static int sort_field_by_offset(ciField** a, ciField** b) {
480   return (*a)->offset_in_bytes() - (*b)->offset_in_bytes();
481   // (no worries about 32-bit overflow...)
482 }
483 
484 // ------------------------------------------------------------------
485 // ciInstanceKlass::compute_nonstatic_fields
486 int ciInstanceKlass::compute_nonstatic_fields() {
487   assert(is_loaded(), "must be loaded");
488 
489   if (_nonstatic_fields != NULL)
490     return _nonstatic_fields->length();
491 
492   if (!has_nonstatic_fields()) {
493     Arena* arena = CURRENT_ENV->arena();
494     _nonstatic_fields = new (arena) GrowableArray<ciField*>(arena, 0, 0, NULL);
495     return 0;
496   }
497   assert(!is_java_lang_Object(), "bootstrap OK");
498 
499   ciInstanceKlass* super = this->super();
500   GrowableArray<ciField*>* super_fields = NULL;
501   if (super != NULL && super->has_nonstatic_fields()) {
502     int super_flen   = super->nof_nonstatic_fields();
503     super_fields = super->_nonstatic_fields;
504     assert(super_flen == 0 || super_fields != NULL, "first get nof_fields");
505   }
506 
507   GrowableArray<ciField*>* fields = NULL;
508   GUARDED_VM_ENTRY({
509       fields = compute_nonstatic_fields_impl(super_fields);
510     });
511 
512   if (fields == NULL) {
513     // This can happen if this class (java.lang.Class) has invisible fields.
514     if (super_fields != NULL) {
515       _nonstatic_fields = super_fields;
516       return super_fields->length();
517     } else {
518       return 0;
519     }
520   }
521 
522   _nonstatic_fields = fields;
523   return fields->length();
524 }
525 
526 GrowableArray<ciField*>* ciInstanceKlass::compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields, bool flatten) {
527   ASSERT_IN_VM;
528   Arena* arena = CURRENT_ENV->arena();
529   int flen = 0;
530   GrowableArray<ciField*>* fields = NULL;
531   InstanceKlass* k = get_instanceKlass();
532   for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
533     if (fs.access_flags().is_static())  continue;
534     flen += 1;
535   }
536 
537   // allocate the array:
538   if (flen == 0) {
539     return NULL;  // return nothing if none are locally declared
540   }
541   if (super_fields != NULL) {
542     flen += super_fields->length();
543   }
544 
545   fields = new (arena) GrowableArray<ciField*>(arena, flen, 0, NULL);
546   if (super_fields != NULL) {
547     fields->appendAll(super_fields);
548   }
549 
550   for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
551     if (fs.access_flags().is_static())  continue;
552     fieldDescriptor& fd = fs.field_descriptor();
553     if (fd.is_inlined() && flatten) {
554       // Inline type fields are embedded
555       int field_offset = fd.offset();
556       // Get InlineKlass and adjust number of fields
557       Klass* k = get_instanceKlass()->get_inline_type_field_klass(fd.index());
558       ciInlineKlass* vk = CURRENT_ENV->get_klass(k)->as_inline_klass();
559       flen += vk->nof_nonstatic_fields() - 1;
560       // Iterate over fields of the flattened inline type and copy them to 'this'
561       for (int i = 0; i < vk->nof_nonstatic_fields(); ++i) {
562         ciField* flattened_field = vk->nonstatic_field_at(i);
563         // Adjust offset to account for missing oop header
564         int offset = field_offset + (flattened_field->offset() - vk->first_field_offset());
565         // A flattened field can be treated as final if the non-flattened
566         // field is declared final or the holder klass is an inline type itself.
567         bool is_final = fd.is_final() || is_inlinetype();
568         ciField* field = new (arena) ciField(flattened_field, this, offset, is_final);
569         fields->append(field);
570       }
571     } else {
572       ciField* field = new (arena) ciField(&fd);
573       fields->append(field);
574     }
575   }
576   assert(fields->length() == flen, "sanity");
577   // Now sort them by offset, ascending.
578   // (In principle, they could mix with superclass fields.)
579   fields->sort(sort_field_by_offset);
580   return fields;
581 }
582 
583 bool ciInstanceKlass::compute_injected_fields_helper() {
584   ASSERT_IN_VM;
585   InstanceKlass* k = get_instanceKlass();
586 
587   for (InternalFieldStream fs(k); !fs.done(); fs.next()) {
588     if (fs.access_flags().is_static())  continue;
589     return true;
590   }
591   return false;
592 }
593 
594 void ciInstanceKlass::compute_injected_fields() {
595   assert(is_loaded(), "must be loaded");
596 
597   int has_injected_fields = 0;
598   if (super() != NULL && super()->has_injected_fields()) {
599     has_injected_fields = 1;
600   } else {
601     GUARDED_VM_ENTRY({
602         has_injected_fields = compute_injected_fields_helper() ? 1 : 0;
603       });
604   }
605   // may be concurrently initialized for shared ciInstanceKlass objects
606   assert(_has_injected_fields == -1 || _has_injected_fields == has_injected_fields, "broken concurrent initialization");
607   _has_injected_fields = has_injected_fields;
608 }
609 
610 bool ciInstanceKlass::has_object_fields() const {
611   GUARDED_VM_ENTRY(
612       return get_instanceKlass()->nonstatic_oop_map_size() > 0;
613     );
614 }
615 
616 bool ciInstanceKlass::compute_has_trusted_loader() {
617   ASSERT_IN_VM;
618   oop loader_oop = loader();
619   if (loader_oop == NULL) {
620     return true; // bootstrap class loader
621   }
622   return java_lang_ClassLoader::is_trusted_loader(loader_oop);
623 }
624 
625 // ------------------------------------------------------------------
626 // ciInstanceKlass::find_method
627 //
628 // Find a method in this klass.
629 ciMethod* ciInstanceKlass::find_method(ciSymbol* name, ciSymbol* signature) {
630   VM_ENTRY_MARK;
631   InstanceKlass* k = get_instanceKlass();
632   Symbol* name_sym = name->get_symbol();
633   Symbol* sig_sym= signature->get_symbol();
634 
635   Method* m = k->find_method(name_sym, sig_sym);
636   if (m == NULL)  return NULL;
637 
638   return CURRENT_THREAD_ENV->get_method(m);
639 }
640 
641 // ------------------------------------------------------------------
642 // ciInstanceKlass::is_leaf_type
643 bool ciInstanceKlass::is_leaf_type() {
644   assert(is_loaded(), "must be loaded");
645   if (is_shared()) {
646     return is_final();  // approximately correct
647   } else {
648     return !has_subklass() && (nof_implementors() == 0);
649   }
650 }
651 
652 // ------------------------------------------------------------------
653 // ciInstanceKlass::implementor
654 //
655 // Report an implementor of this interface.
656 // Note that there are various races here, since my copy
657 // of _nof_implementors might be out of date with respect
658 // to results returned by InstanceKlass::implementor.
659 // This is OK, since any dependencies we decide to assert
660 // will be checked later under the Compile_lock.
661 ciInstanceKlass* ciInstanceKlass::implementor() {
662   ciInstanceKlass* impl = _implementor;
663   if (impl == NULL) {
664     if (is_shared()) {
665       impl = this; // assume a well-known interface never has a unique implementor
666     } else {
667       // Go into the VM to fetch the implementor.
668       VM_ENTRY_MARK;
669       MutexLocker ml(Compile_lock);
670       Klass* k = get_instanceKlass()->implementor();
671       if (k != NULL) {
672         if (k == get_instanceKlass()) {
673           // More than one implementors. Use 'this' in this case.
674           impl = this;
675         } else {
676           impl = CURRENT_THREAD_ENV->get_instance_klass(k);
677         }
678       }
679     }
680     // Memoize this result.
681     _implementor = impl;
682   }
683   return impl;
684 }
685 
686 bool ciInstanceKlass::can_be_inline_klass(bool is_exact) {
687   if (!EnableValhalla) {
688     return false;
689   }
690   if (!is_loaded() || is_inlinetype()) {
691     // Not loaded or known to be an inline klass
692     return true;
693   }
694   if (!is_exact) {
695     // Not exact, check if this is a valid super for an inline klass
696     VM_ENTRY_MARK;
697     return !get_instanceKlass()->carries_identity_modifier();
698   }
699   return false;
700 }
701 
702 // Utility class for printing of the contents of the static fields for
703 // use by compilation replay.  It only prints out the information that
704 // could be consumed by the compiler, so for primitive types it prints
705 // out the actual value.  For Strings it's the actual string value.
706 // For array types it it's first level array size since that's the
707 // only value which statically unchangeable.  For all other reference
708 // types it simply prints out the dynamic type.
709 
710 class StaticFieldPrinter : public FieldClosure {
711 protected:
712   outputStream* _out;
713 public:
714   StaticFieldPrinter(outputStream* out) :
715     _out(out) {
716   }
717   void do_field_helper(fieldDescriptor* fd, oop obj, bool flattened);
718 };
719 
720 class StaticFinalFieldPrinter : public StaticFieldPrinter {
721   const char*   _holder;
722  public:
723   StaticFinalFieldPrinter(outputStream* out, const char* holder) :
724     StaticFieldPrinter(out), _holder(holder) {
725   }
726   void do_field(fieldDescriptor* fd) {
727     if (fd->is_final() && !fd->has_initial_value()) {
728       ResourceMark rm;
729       InstanceKlass* holder = fd->field_holder();
730       oop mirror = holder->java_mirror();
731       _out->print("staticfield %s %s ", _holder, fd->name()->as_quoted_ascii());
732       BasicType bt = fd->field_type();
733       if (bt != T_OBJECT && bt != T_ARRAY) {
734         _out->print("%s ", fd->signature()->as_quoted_ascii());
735       }
736       do_field_helper(fd, mirror, false);
737       _out->cr();
738     }
739   }
740 };
741 
742 class InlineTypeFieldPrinter : public StaticFieldPrinter {
743   oop _obj;
744 public:
745   InlineTypeFieldPrinter(outputStream* out, oop obj) :
746     StaticFieldPrinter(out), _obj(obj) {
747   }
748   void do_field(fieldDescriptor* fd) {
749     do_field_helper(fd, _obj, true);
750     _out->print(" ");
751   }
752 };
753 
754 void StaticFieldPrinter::do_field_helper(fieldDescriptor* fd, oop mirror, bool flattened) {
755   BasicType bt = fd->field_type();
756   switch (bt) {
757     case T_BYTE:    _out->print("%d", mirror->byte_field(fd->offset()));   break;
758     case T_BOOLEAN: _out->print("%d", mirror->bool_field(fd->offset()));   break;
759     case T_SHORT:   _out->print("%d", mirror->short_field(fd->offset()));  break;
760     case T_CHAR:    _out->print("%d", mirror->char_field(fd->offset()));   break;
761     case T_INT:     _out->print("%d", mirror->int_field(fd->offset()));    break;
762     case T_LONG:    _out->print(INT64_FORMAT, (int64_t)(mirror->long_field(fd->offset())));   break;
763     case T_FLOAT: {
764       float f = mirror->float_field(fd->offset());
765       _out->print("%d", *(int*)&f);
766       break;
767     }
768     case T_DOUBLE: {
769       double d = mirror->double_field(fd->offset());
770       _out->print(INT64_FORMAT, *(int64_t*)&d);
771       break;
772     }
773     case T_ARRAY:  // fall-through
774     case T_OBJECT: {
775       _out->print("%s ", fd->signature()->as_quoted_ascii());
776       oop value =  mirror->obj_field_acquire(fd->offset());
777       if (value == NULL) {
778         _out->print_cr("null");
779       } else if (value->is_instance()) {
780         assert(fd->field_type() == T_OBJECT, "");
781         if (value->is_a(vmClasses::String_klass())) {
782           const char* ascii_value = java_lang_String::as_quoted_ascii(value);
783           _out->print("\"%s\"", (ascii_value != NULL) ? ascii_value : "");
784          } else {
785           const char* klass_name  = value->klass()->name()->as_quoted_ascii();
786           _out->print("%s", klass_name);
787         }
788       } else if (value->is_array()) {
789         typeArrayOop ta = (typeArrayOop)value;
790         _out->print("%d", ta->length());
791         if (value->is_objArray() || value->is_flatArray()) {
792           objArrayOop oa = (objArrayOop)value;
793           const char* klass_name  = value->klass()->name()->as_quoted_ascii();
794           _out->print(" %s", klass_name);
795         }
796       } else {
797         ShouldNotReachHere();
798       }
799       break;
800     }
801     case T_PRIMITIVE_OBJECT: {
802       ResetNoHandleMark rnhm;
803       Thread* THREAD = Thread::current();
804       SignatureStream ss(fd->signature(), false);
805       Symbol* name = ss.as_symbol();
806       assert(!HAS_PENDING_EXCEPTION, "can resolve klass?");
807       InstanceKlass* holder = fd->field_holder();
808       InstanceKlass* k = SystemDictionary::find_instance_klass(THREAD, name,
809                                                                Handle(THREAD, holder->class_loader()),
810                                                                Handle(THREAD, holder->protection_domain()));
811       assert(k != NULL && !HAS_PENDING_EXCEPTION, "can resolve klass?");
812       InlineKlass* vk = InlineKlass::cast(k);
813       oop obj;
814       if (flattened) {
815         int field_offset = fd->offset() - vk->first_field_offset();
816         obj = cast_to_oop(cast_from_oop<address>(mirror) + field_offset);
817       } else {
818         obj = mirror->obj_field_acquire(fd->offset());
819       }
820       InlineTypeFieldPrinter print_field(_out, obj);
821       vk->do_nonstatic_fields(&print_field);
822       break;
823     }
824     default:
825       ShouldNotReachHere();
826   }
827 }
828 
829 const char *ciInstanceKlass::replay_name() const {
830   return CURRENT_ENV->replay_name(get_instanceKlass());
831 }
832 
833 void ciInstanceKlass::dump_replay_instanceKlass(outputStream* out, InstanceKlass* ik) {
834   if (ik->is_hidden()) {
835     const char *name = CURRENT_ENV->dyno_name(ik);
836     if (name != NULL) {
837       out->print_cr("instanceKlass %s # %s", name, ik->name()->as_quoted_ascii());
838     } else {
839       out->print_cr("# instanceKlass %s", ik->name()->as_quoted_ascii());
840     }
841   } else {
842     out->print_cr("instanceKlass %s", ik->name()->as_quoted_ascii());
843   }
844 }
845 
846 void ciInstanceKlass::dump_replay_data(outputStream* out) {
847   ResourceMark rm;
848 
849   InstanceKlass* ik = get_instanceKlass();
850   ConstantPool*  cp = ik->constants();
851 
852   // Try to record related loaded classes
853   Klass* sub = ik->subklass();
854   while (sub != NULL) {
855     if (sub->is_instance_klass()) {
856       InstanceKlass *isub = InstanceKlass::cast(sub);
857       dump_replay_instanceKlass(out, isub);
858     }
859     sub = sub->next_sibling();
860   }
861 
862   // Dump out the state of the constant pool tags.  During replay the
863   // tags will be validated for things which shouldn't change and
864   // classes will be resolved if the tags indicate that they were
865   // resolved at compile time.
866   const char *name = replay_name();
867   out->print("ciInstanceKlass %s %d %d %d", name,
868              is_linked(), is_initialized(), cp->length());
869   for (int index = 1; index < cp->length(); index++) {
870     out->print(" %d", cp->tags()->at(index));
871   }
872   out->cr();
873   if (is_initialized()) {
874     //  Dump out the static final fields in case the compilation relies
875     //  on their value for correct replay.
876     StaticFinalFieldPrinter sffp(out, name);
877     ik->do_local_static_fields(&sffp);
878   }
879 }
880 
881 #ifdef ASSERT
882 bool ciInstanceKlass::debug_final_field_at(int offset) {
883   GUARDED_VM_ENTRY(
884     InstanceKlass* ik = get_instanceKlass();
885     fieldDescriptor fd;
886     if (ik->find_field_from_offset(offset, false, &fd)) {
887       return fd.is_final();
888     }
889   );
890   return false;
891 }
892 
893 bool ciInstanceKlass::debug_stable_field_at(int offset) {
894   GUARDED_VM_ENTRY(
895     InstanceKlass* ik = get_instanceKlass();
896     fieldDescriptor fd;
897     if (ik->find_field_from_offset(offset, false, &fd)) {
898       return fd.is_stable();
899     }
900   );
901   return false;
902 }
903 #endif