< prev index next >

src/hotspot/share/ci/ciInstanceKlass.cpp

Print this page




  48 //
  49 // Loaded instance klass.
  50 ciInstanceKlass::ciInstanceKlass(Klass* k) :
  51   ciKlass(k)
  52 {
  53   assert(get_Klass()->is_instance_klass(), "wrong type");
  54   assert(get_instanceKlass()->is_loaded(), "must be at least loaded");
  55   InstanceKlass* ik = get_instanceKlass();
  56 
  57   AccessFlags access_flags = ik->access_flags();
  58   _flags = ciFlags(access_flags);
  59   _has_finalizer = access_flags.has_finalizer();
  60   _has_subklass = ik->subklass() != NULL;
  61   _init_state = ik->init_state();
  62   _nonstatic_field_size = ik->nonstatic_field_size();
  63   _has_nonstatic_fields = ik->has_nonstatic_fields();
  64   _has_nonstatic_concrete_methods = ik->has_nonstatic_concrete_methods();
  65   _is_anonymous = ik->is_anonymous();
  66   _nonstatic_fields = NULL; // initialized lazily by compute_nonstatic_fields:
  67   _has_injected_fields = -1;

  68   _implementor = NULL; // we will fill these lazily
  69 
  70   // Ensure that the metadata wrapped by the ciMetadata is kept alive by GC.
  71   // This is primarily useful for metadata which is considered as weak roots
  72   // by the GC but need to be strong roots if reachable from a current compilation.
  73   // InstanceKlass are created for both weak and strong metadata.  Ensuring this metadata
  74   // alive covers the cases where there are weak roots without performance cost.
  75   oop holder = ik->holder_phantom();
  76   if (ik->is_anonymous()) {
  77     // Though ciInstanceKlass records class loader oop, it's not enough to keep
  78     // VM anonymous classes alive (loader == NULL). Klass holder should be used instead.
  79     // It is enough to record a ciObject, since cached elements are never removed
  80     // during ciObjectFactory lifetime. ciObjectFactory itself is created for
  81     // every compilation and lives for the whole duration of the compilation.
  82     assert(holder != NULL, "holder of anonymous class is the mirror which is never null");
  83     (void)CURRENT_ENV->get_object(holder);
  84   }
  85 
  86   Thread *thread = Thread::current();
  87   if (ciObjectFactory::is_initialized()) {


 105     if (k != SystemDictionary::Object_klass()) {
 106       super();
 107     }
 108     //compute_nonstatic_fields();  // done outside of constructor
 109   }
 110 
 111   _field_cache = NULL;
 112 }
 113 
 114 // Version for unloaded classes:
 115 ciInstanceKlass::ciInstanceKlass(ciSymbol* name,
 116                                  jobject loader, jobject protection_domain)
 117   : ciKlass(name, T_OBJECT)
 118 {
 119   assert(name->byte_at(0) != '[', "not an instance klass");
 120   _init_state = (InstanceKlass::ClassState)0;
 121   _nonstatic_field_size = -1;
 122   _has_nonstatic_fields = false;
 123   _nonstatic_fields = NULL;
 124   _has_injected_fields = -1;

 125   _is_anonymous = false;
 126   _loader = loader;
 127   _protection_domain = protection_domain;
 128   _is_shared = false;
 129   _super = NULL;
 130   _java_mirror = NULL;
 131   _field_cache = NULL;
 132 }
 133 
 134 
 135 
 136 // ------------------------------------------------------------------
 137 // ciInstanceKlass::compute_shared_is_initialized
 138 void ciInstanceKlass::compute_shared_init_state() {
 139   GUARDED_VM_ENTRY(
 140     InstanceKlass* ik = get_instanceKlass();
 141     _init_state = ik->init_state();
 142   )
 143 }
 144 


 535     if (fs.access_flags().is_static())  continue;
 536     return true;
 537   }
 538   return false;
 539 }
 540 
 541 void ciInstanceKlass::compute_injected_fields() {
 542   assert(is_loaded(), "must be loaded");
 543 
 544   int has_injected_fields = 0;
 545   if (super() != NULL && super()->has_injected_fields()) {
 546     has_injected_fields = 1;
 547   } else {
 548     GUARDED_VM_ENTRY({
 549         has_injected_fields = compute_injected_fields_helper() ? 1 : 0;
 550       });
 551   }
 552   // may be concurrently initialized for shared ciInstanceKlass objects
 553   assert(_has_injected_fields == -1 || _has_injected_fields == has_injected_fields, "broken concurrent initialization");
 554   _has_injected_fields = has_injected_fields;













 555 }
 556 
 557 // ------------------------------------------------------------------
 558 // ciInstanceKlass::find_method
 559 //
 560 // Find a method in this klass.
 561 ciMethod* ciInstanceKlass::find_method(ciSymbol* name, ciSymbol* signature) {
 562   VM_ENTRY_MARK;
 563   InstanceKlass* k = get_instanceKlass();
 564   Symbol* name_sym = name->get_symbol();
 565   Symbol* sig_sym= signature->get_symbol();
 566 
 567   Method* m = k->find_method(name_sym, sig_sym);
 568   if (m == NULL)  return NULL;
 569 
 570   return CURRENT_THREAD_ENV->get_method(m);
 571 }
 572 
 573 // ------------------------------------------------------------------
 574 // ciInstanceKlass::is_leaf_type




  48 //
  49 // Loaded instance klass.
  50 ciInstanceKlass::ciInstanceKlass(Klass* k) :
  51   ciKlass(k)
  52 {
  53   assert(get_Klass()->is_instance_klass(), "wrong type");
  54   assert(get_instanceKlass()->is_loaded(), "must be at least loaded");
  55   InstanceKlass* ik = get_instanceKlass();
  56 
  57   AccessFlags access_flags = ik->access_flags();
  58   _flags = ciFlags(access_flags);
  59   _has_finalizer = access_flags.has_finalizer();
  60   _has_subklass = ik->subklass() != NULL;
  61   _init_state = ik->init_state();
  62   _nonstatic_field_size = ik->nonstatic_field_size();
  63   _has_nonstatic_fields = ik->has_nonstatic_fields();
  64   _has_nonstatic_concrete_methods = ik->has_nonstatic_concrete_methods();
  65   _is_anonymous = ik->is_anonymous();
  66   _nonstatic_fields = NULL; // initialized lazily by compute_nonstatic_fields:
  67   _has_injected_fields = -1;
  68   _has_object_fields = -1;
  69   _implementor = NULL; // we will fill these lazily
  70 
  71   // Ensure that the metadata wrapped by the ciMetadata is kept alive by GC.
  72   // This is primarily useful for metadata which is considered as weak roots
  73   // by the GC but need to be strong roots if reachable from a current compilation.
  74   // InstanceKlass are created for both weak and strong metadata.  Ensuring this metadata
  75   // alive covers the cases where there are weak roots without performance cost.
  76   oop holder = ik->holder_phantom();
  77   if (ik->is_anonymous()) {
  78     // Though ciInstanceKlass records class loader oop, it's not enough to keep
  79     // VM anonymous classes alive (loader == NULL). Klass holder should be used instead.
  80     // It is enough to record a ciObject, since cached elements are never removed
  81     // during ciObjectFactory lifetime. ciObjectFactory itself is created for
  82     // every compilation and lives for the whole duration of the compilation.
  83     assert(holder != NULL, "holder of anonymous class is the mirror which is never null");
  84     (void)CURRENT_ENV->get_object(holder);
  85   }
  86 
  87   Thread *thread = Thread::current();
  88   if (ciObjectFactory::is_initialized()) {


 106     if (k != SystemDictionary::Object_klass()) {
 107       super();
 108     }
 109     //compute_nonstatic_fields();  // done outside of constructor
 110   }
 111 
 112   _field_cache = NULL;
 113 }
 114 
 115 // Version for unloaded classes:
 116 ciInstanceKlass::ciInstanceKlass(ciSymbol* name,
 117                                  jobject loader, jobject protection_domain)
 118   : ciKlass(name, T_OBJECT)
 119 {
 120   assert(name->byte_at(0) != '[', "not an instance klass");
 121   _init_state = (InstanceKlass::ClassState)0;
 122   _nonstatic_field_size = -1;
 123   _has_nonstatic_fields = false;
 124   _nonstatic_fields = NULL;
 125   _has_injected_fields = -1;
 126   _has_object_fields = -1;
 127   _is_anonymous = false;
 128   _loader = loader;
 129   _protection_domain = protection_domain;
 130   _is_shared = false;
 131   _super = NULL;
 132   _java_mirror = NULL;
 133   _field_cache = NULL;
 134 }
 135 
 136 
 137 
 138 // ------------------------------------------------------------------
 139 // ciInstanceKlass::compute_shared_is_initialized
 140 void ciInstanceKlass::compute_shared_init_state() {
 141   GUARDED_VM_ENTRY(
 142     InstanceKlass* ik = get_instanceKlass();
 143     _init_state = ik->init_state();
 144   )
 145 }
 146 


 537     if (fs.access_flags().is_static())  continue;
 538     return true;
 539   }
 540   return false;
 541 }
 542 
 543 void ciInstanceKlass::compute_injected_fields() {
 544   assert(is_loaded(), "must be loaded");
 545 
 546   int has_injected_fields = 0;
 547   if (super() != NULL && super()->has_injected_fields()) {
 548     has_injected_fields = 1;
 549   } else {
 550     GUARDED_VM_ENTRY({
 551         has_injected_fields = compute_injected_fields_helper() ? 1 : 0;
 552       });
 553   }
 554   // may be concurrently initialized for shared ciInstanceKlass objects
 555   assert(_has_injected_fields == -1 || _has_injected_fields == has_injected_fields, "broken concurrent initialization");
 556   _has_injected_fields = has_injected_fields;
 557 }
 558 
 559 void ciInstanceKlass::compute_object_fields() {
 560   for (int i = 0; i < nof_nonstatic_fields(); i++) {
 561     ciField* f = nonstatic_field_at(i);
 562     if (f->layout_type() == T_OBJECT) {
 563       assert(_has_object_fields == -1 || _has_object_fields == 1, "broken concurrent initialization");
 564       _has_object_fields = 1;
 565       return;
 566     }
 567   }
 568   assert(_has_object_fields == -1 || _has_object_fields == 0, "broken concurrent initialization");
 569   _has_object_fields = 0;
 570 }
 571 
 572 // ------------------------------------------------------------------
 573 // ciInstanceKlass::find_method
 574 //
 575 // Find a method in this klass.
 576 ciMethod* ciInstanceKlass::find_method(ciSymbol* name, ciSymbol* signature) {
 577   VM_ENTRY_MARK;
 578   InstanceKlass* k = get_instanceKlass();
 579   Symbol* name_sym = name->get_symbol();
 580   Symbol* sig_sym= signature->get_symbol();
 581 
 582   Method* m = k->find_method(name_sym, sig_sym);
 583   if (m == NULL)  return NULL;
 584 
 585   return CURRENT_THREAD_ENV->get_method(m);
 586 }
 587 
 588 // ------------------------------------------------------------------
 589 // ciInstanceKlass::is_leaf_type


< prev index next >