1 /*

     2  * Copyright (c) 1999, 2017, 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 #ifndef SHARE_VM_CI_CIINSTANCEKLASS_HPP

    26 #define SHARE_VM_CI_CIINSTANCEKLASS_HPP

    27 

    28 #include "ci/ciConstantPoolCache.hpp"

    29 #include "ci/ciFlags.hpp"

    30 #include "ci/ciKlass.hpp"

    31 #include "ci/ciSymbol.hpp"

    32 

    33 // ciInstanceKlass

    34 //

    35 // This class represents a Klass* in the HotSpot virtual machine

    36 // whose Klass part is an InstanceKlass.  It may or may not

    37 // be loaded.

    38 class ciInstanceKlass : public ciKlass {

    39   CI_PACKAGE_ACCESS

    40   friend class ciBytecodeStream;

    41   friend class ciEnv;

    42   friend class ciExceptionHandler;

    43   friend class ciMethod;

    44   friend class ciField;

    45 

    46 private:

    47   jobject                _loader;

    48   jobject                _protection_domain;

    49 

    50   InstanceKlass::ClassState _init_state;           // state of class

    51   bool                   _is_shared;

    52   bool                   _has_finalizer;

    53   bool                   _has_subklass;

    54   bool                   _has_nonstatic_fields;

    55   bool                   _has_nonstatic_concrete_methods;

    56   bool                   _is_anonymous;

    57 

    58   ciFlags                _flags;

    59   jint                   _nonstatic_field_size;

    60   jint                   _nonstatic_oop_map_size;

    61 

    62   // Lazy fields get filled in only upon request.

    63   ciInstanceKlass*       _super;

    64   ciInstance*            _java_mirror;

    65 

    66   ciConstantPoolCache*   _field_cache;  // cached map index->field

    67   GrowableArray<ciField*>* _nonstatic_fields;

    68   int                    _has_injected_fields; // any non static injected fields? lazily initialized.

    69 

    70   // The possible values of the _implementor fall into following three cases:

    71   //   NULL: no implementor.

    72   //   A ciInstanceKlass that's not itself: one implementor.

    73   //   Itsef: more than one implementors.

    74   ciInstanceKlass*       _implementor;

    75 

    76   void compute_injected_fields();

    77   bool compute_injected_fields_helper();

    78 

    79 protected:

    80   ciInstanceKlass(Klass* k);

    81   ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain);

    82 

    83   InstanceKlass* get_instanceKlass() const {

    84     return InstanceKlass::cast(get_Klass());

    85   }

    86 

    87   oop loader();

    88   jobject loader_handle();

    89 

    90   oop protection_domain();

    91   jobject protection_domain_handle();

    92 

    93   const char* type_string() { return "ciInstanceKlass"; }

    94 

    95   bool is_in_package_impl(const char* packagename, int len);

    96 

    97   void print_impl(outputStream* st);

    98 

    99   ciConstantPoolCache* field_cache();

   100 

   101   bool is_shared() { return _is_shared; }

   102 

   103   void compute_shared_init_state();

   104   bool compute_shared_has_subklass();

   105   int  compute_nonstatic_fields();

   106   GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);

   107 

   108   // Update the init_state for shared klasses

   109   void update_if_shared(InstanceKlass::ClassState expected) {

   110     if (_is_shared && _init_state != expected) {

   111       if (is_loaded()) compute_shared_init_state();

   112     }

   113   }

   114 

   115 public:

   116   // Has this klass been initialized?

   117   bool                   is_initialized() {

   118     update_if_shared(InstanceKlass::fully_initialized);

   119     return _init_state == InstanceKlass::fully_initialized;

   120   }

   121   // Is this klass being initialized?

   122   bool                   is_being_initialized() {

   123     update_if_shared(InstanceKlass::being_initialized);

   124     return _init_state == InstanceKlass::being_initialized;

   125   }

   126   // Has this klass been linked?

   127   bool                   is_linked() {

   128     update_if_shared(InstanceKlass::linked);

   129     return _init_state >= InstanceKlass::linked;

   130   }

   131 

   132   // General klass information.

   133   ciFlags                flags()          {

   134     assert(is_loaded(), "must be loaded");

   135     return _flags;

   136   }

   137   bool                   has_finalizer()  {

   138     assert(is_loaded(), "must be loaded");

   139     return _has_finalizer; }

   140   bool                   has_subklass()   {

   141     assert(is_loaded(), "must be loaded");

   142     if (_is_shared && !_has_subklass) {

   143       if (flags().is_final()) {

   144         return false;

   145       } else {

   146         return compute_shared_has_subklass();

   147       }

   148     }

   149     return _has_subklass;

   150   }

   151   jint                   size_helper()  {

   152     return (Klass::layout_helper_size_in_bytes(layout_helper())

   153             >> LogHeapWordSize);

   154   }

   155   jint                   nonstatic_field_size()  {

   156     assert(is_loaded(), "must be loaded");

   157     return _nonstatic_field_size; }

   158   jint                   has_nonstatic_fields()  {

   159     assert(is_loaded(), "must be loaded");

   160     return _has_nonstatic_fields; }

   161   jint                   nonstatic_oop_map_size()  {

   162     assert(is_loaded(), "must be loaded");

   163     return _nonstatic_oop_map_size; }

   164   ciInstanceKlass*       super();

   165   jint                   nof_implementors() {

   166     ciInstanceKlass* impl;

   167     assert(is_loaded(), "must be loaded");

   168     impl = implementor();

   169     if (impl == NULL) {

   170       return 0;

   171     } else if (impl != this) {

   172       return 1;

   173     } else {

   174       return 2;

   175     }

   176   }

   177   bool has_nonstatic_concrete_methods()  {

   178     assert(is_loaded(), "must be loaded");

   179     return _has_nonstatic_concrete_methods;

   180   }

   181 

   182   bool is_anonymous() {

   183     return _is_anonymous;

   184   }

   185 

   186   ciInstanceKlass* get_canonical_holder(int offset);

   187   ciField* get_field_by_offset(int field_offset, bool is_static);

   188   ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static);

   189 

   190   // total number of nonstatic fields (including inherited):

   191   int nof_nonstatic_fields() {

   192     if (_nonstatic_fields == NULL)

   193       return compute_nonstatic_fields();

   194     else

   195       return _nonstatic_fields->length();

   196   }

   197 

   198   bool has_injected_fields() {

   199     if (_has_injected_fields == -1) {

   200       compute_injected_fields();

   201     }

   202     return _has_injected_fields > 0 ? true : false;

   203   }

   204 

   205   // nth nonstatic field (presented by ascending address)

   206   ciField* nonstatic_field_at(int i) {

   207     assert(_nonstatic_fields != NULL, "");

   208     return _nonstatic_fields->at(i);

   209   }

   210 

   211   ciInstanceKlass* unique_concrete_subklass();

   212   bool has_finalizable_subclass();

   213 

   214   bool contains_field_offset(int offset) {

   215     return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());

   216   }

   217 

   218   // Get the instance of java.lang.Class corresponding to

   219   // this klass.  This instance is used for locking of

   220   // synchronized static methods of this klass.

   221   ciInstance*            java_mirror();

   222 

   223   // Java access flags

   224   bool is_public      () { return flags().is_public(); }

   225   bool is_final       () { return flags().is_final(); }

   226   bool is_super       () { return flags().is_super(); }

   227   bool is_interface   () { return flags().is_interface(); }

   228   bool is_abstract    () { return flags().is_abstract(); }

   229 

   230   ciMethod* find_method(ciSymbol* name, ciSymbol* signature);

   231   // Note:  To find a method from name and type strings, use ciSymbol::make,

   232   // but consider adding to vmSymbols.hpp instead.

   233 

   234   bool is_leaf_type();

   235   ciInstanceKlass* implementor();

   236 

   237   // Is the defining class loader of this class the default loader?

   238   bool uses_default_loader() const;

   239 

   240   bool is_java_lang_Object() const;

   241 

   242   BasicType box_klass_type() const;

   243   bool is_box_klass() const;

   244   bool is_boxed_value_offset(int offset) const;

   245 

   246   // Is this klass in the given package?

   247   bool is_in_package(const char* packagename) {

   248     return is_in_package(packagename, (int) strlen(packagename));

   249   }

   250   bool is_in_package(const char* packagename, int len);

   251 

   252   // What kind of ciObject is this?

   253   bool is_instance_klass() const { return true; }

   254   bool is_java_klass() const     { return true; }

   255 

   256   virtual ciKlass* exact_klass() {

   257     if (is_loaded() && is_final() && !is_interface()) {

   258       return this;

   259     }

   260     return NULL;

   261   }

   262 

   263   ciInstanceKlass* host_klass();

   264 

   265   bool can_be_instantiated() {

   266     assert(is_loaded(), "must be loaded");

   267     return !is_interface() && !is_abstract();

   268   }

   269 

   270   // Dump the current state of this klass for compilation replay.

   271   virtual void dump_replay_data(outputStream* out);

   272 };

   273 

   274 #endif // SHARE_VM_CI_CIINSTANCEKLASS_HPP