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 #ifndef SHARE_CI_CIINSTANCEKLASS_HPP 26 #define SHARE_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 #include "oops/instanceKlass.hpp" 33 34 // ciInstanceKlass 35 // 36 // This class represents a Klass* in the HotSpot virtual machine 37 // whose Klass part is an InstanceKlass. It may or may not 38 // be loaded. 39 class ciInstanceKlass : public ciKlass { 40 CI_PACKAGE_ACCESS 41 friend class ciBytecodeStream; 42 friend class ciEnv; 43 friend class ciExceptionHandler; 44 friend class ciMethod; 45 friend class ciField; 46 friend class ciReplay; 47 48 private: 49 enum SubklassValue { subklass_unknown, subklass_false, subklass_true }; 50 51 jobject _loader; 52 jobject _protection_domain; 53 54 InstanceKlass::ClassState _init_state; // state of class 55 bool _is_shared; 56 bool _has_finalizer; 57 SubklassValue _has_subklass; 58 bool _has_nonstatic_fields; 59 bool _has_nonstatic_concrete_methods; 60 bool _is_hidden; 61 bool _is_record; 62 bool _has_trusted_loader; 63 64 ciFlags _flags; 65 66 // Lazy fields get filled in only upon request. 67 ciInstanceKlass* _super; 68 ciInstance* _java_mirror; 69 70 ciConstantPoolCache* _field_cache; // cached map index->field 71 GrowableArray<ciField*>* _nonstatic_fields; 72 73 int _has_injected_fields; // any non static injected fields? lazily initialized. 74 75 // The possible values of the _implementor fall into following three cases: 76 // NULL: no implementor. 77 // A ciInstanceKlass that's not itself: one implementor. 78 // Itself: more than one implementor. 79 ciInstanceKlass* _implementor; 80 GrowableArray<ciInstanceKlass*>* _transitive_interfaces; 81 82 void compute_injected_fields(); 83 bool compute_injected_fields_helper(); 84 void compute_transitive_interfaces(); 85 86 protected: 87 ciInstanceKlass(Klass* k); 88 ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain, BasicType bt = T_OBJECT); // for unloaded klasses 89 90 InstanceKlass* get_instanceKlass() const { 91 return InstanceKlass::cast(get_Klass()); 92 } 93 94 oop loader(); 95 jobject loader_handle(); 96 97 oop protection_domain(); 98 jobject protection_domain_handle(); 99 100 const char* type_string() { return "ciInstanceKlass"; } 101 102 bool is_in_package_impl(const char* packagename, int len); 103 104 void print_impl(outputStream* st); 105 106 ciConstantPoolCache* field_cache(); 107 108 bool is_shared() { return _is_shared; } 109 110 void compute_shared_init_state(); 111 bool compute_shared_has_subklass(); 112 virtual int compute_nonstatic_fields(); 113 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields, bool flatten = true); 114 bool compute_has_trusted_loader(); 115 116 // Update the init_state for shared klasses 117 void update_if_shared(InstanceKlass::ClassState expected) { 118 if (_is_shared && _init_state != expected) { 119 if (is_loaded()) compute_shared_init_state(); 120 } 121 } 122 123 public: 124 // Has this klass been initialized? 125 bool is_initialized() { 126 update_if_shared(InstanceKlass::fully_initialized); 127 return _init_state == InstanceKlass::fully_initialized; 128 } 129 bool is_not_initialized() { 130 update_if_shared(InstanceKlass::fully_initialized); 131 return _init_state < InstanceKlass::being_initialized; 132 } 133 // Is this klass being initialized? 134 bool is_being_initialized() { 135 update_if_shared(InstanceKlass::being_initialized); 136 return _init_state == InstanceKlass::being_initialized; 137 } 138 // Has this klass been linked? 139 bool is_linked() { 140 update_if_shared(InstanceKlass::linked); 141 return _init_state >= InstanceKlass::linked; 142 } 143 // Is this klass in error state? 144 bool is_in_error_state() { 145 update_if_shared(InstanceKlass::initialization_error); 146 return _init_state == InstanceKlass::initialization_error; 147 } 148 149 // General klass information. 150 ciFlags flags() { 151 assert(is_loaded(), "must be loaded"); 152 return _flags; 153 } 154 bool has_finalizer() { 155 assert(is_loaded(), "must be loaded"); 156 return _has_finalizer; } 157 bool has_subklass() { 158 assert(is_loaded(), "must be loaded"); 159 // Ignore cached subklass_false case. 160 // It could be invalidated by concurrent class loading and 161 // can result in type paradoxes during compilation when 162 // a subclass is observed, but has_subklass() returns false. 163 if (_has_subklass == subklass_true) { 164 return true; 165 } 166 if (flags().is_final()) { 167 return false; 168 } 169 return compute_shared_has_subklass(); 170 } 171 172 jint layout_helper_size_in_bytes() { 173 return Klass::layout_helper_size_in_bytes(layout_helper()); 174 } 175 jint size_helper() { 176 return (Klass::layout_helper_size_in_bytes(layout_helper()) 177 >> LogHeapWordSize); 178 } 179 jint has_nonstatic_fields() { 180 assert(is_loaded(), "must be loaded"); 181 return _has_nonstatic_fields; } 182 ciInstanceKlass* super(); 183 jint nof_implementors() { 184 ciInstanceKlass* impl; 185 assert(is_loaded(), "must be loaded"); 186 impl = implementor(); 187 if (impl == NULL) { 188 return 0; 189 } else if (impl != this) { 190 return 1; 191 } else { 192 return 2; 193 } 194 } 195 bool has_nonstatic_concrete_methods() { 196 assert(is_loaded(), "must be loaded"); 197 return _has_nonstatic_concrete_methods; 198 } 199 200 bool is_hidden() const { 201 return _is_hidden; 202 } 203 204 bool is_record() const { 205 return _is_record; 206 } 207 208 ciInstanceKlass* get_canonical_holder(int offset); 209 ciField* get_field_by_offset(int field_offset, bool is_static); 210 ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static); 211 // get field descriptor at field_offset ignoring flattening 212 ciField* get_non_flattened_field_by_offset(int field_offset); 213 214 // total number of nonstatic fields (including inherited): 215 int nof_nonstatic_fields() { 216 if (_nonstatic_fields == NULL) { 217 return compute_nonstatic_fields(); 218 } else { 219 return _nonstatic_fields->length(); 220 } 221 } 222 223 bool has_injected_fields() { 224 if (_has_injected_fields == -1) { 225 compute_injected_fields(); 226 } 227 return _has_injected_fields > 0 ? true : false; 228 } 229 230 bool has_object_fields() const; 231 232 // nth nonstatic field (presented by ascending address) 233 ciField* nonstatic_field_at(int i) { 234 assert(_nonstatic_fields != NULL, ""); 235 return _nonstatic_fields->at(i); 236 } 237 238 ciInstanceKlass* unique_concrete_subklass(); 239 bool has_finalizable_subclass(); 240 241 bool contains_field_offset(int offset); 242 243 // Get the instance of java.lang.Class corresponding to 244 // this klass. This instance is used for locking of 245 // synchronized static methods of this klass. 246 ciInstance* java_mirror(); 247 248 // Java access flags 249 bool is_public () { return flags().is_public(); } 250 bool is_final () { return flags().is_final(); } 251 bool is_interface () { return flags().is_interface(); } 252 bool is_abstract () { return flags().is_abstract(); } 253 254 ciMethod* find_method(ciSymbol* name, ciSymbol* signature); 255 // Note: To find a method from name and type strings, use ciSymbol::make, 256 // but consider adding to vmSymbols.hpp instead. 257 258 bool is_leaf_type(); 259 ciInstanceKlass* implementor(); 260 261 ciInstanceKlass* unique_implementor() { 262 assert(is_loaded(), "must be loaded"); 263 ciInstanceKlass* impl = implementor(); 264 return (impl != this ? impl : NULL); 265 } 266 267 virtual bool can_be_inline_klass(bool is_exact = false); 268 269 // Is the defining class loader of this class the default loader? 270 bool uses_default_loader() const; 271 272 bool is_java_lang_Object() const; 273 274 BasicType box_klass_type() const; 275 bool is_box_klass() const; 276 bool is_boxed_value_offset(int offset) const; 277 278 // Is this klass in the given package? 279 bool is_in_package(const char* packagename) { 280 return is_in_package(packagename, (int) strlen(packagename)); 281 } 282 bool is_in_package(const char* packagename, int len); 283 284 // What kind of ciObject is this? 285 bool is_instance_klass() const { return true; } 286 287 virtual ciKlass* exact_klass() { 288 if (is_loaded() && is_final() && !is_interface()) { 289 return this; 290 } 291 return NULL; 292 } 293 294 bool can_be_instantiated() { 295 assert(is_loaded(), "must be loaded"); 296 return !is_interface() && !is_abstract(); 297 } 298 299 bool has_trusted_loader() const { 300 return _has_trusted_loader; 301 } 302 GrowableArray<ciInstanceKlass*>* transitive_interfaces() const; 303 304 // Replay support 305 306 // Dump the current state of this klass for compilation replay. 307 virtual void dump_replay_data(outputStream* out); 308 309 static void dump_replay_instanceKlass(outputStream* out, InstanceKlass* ik); 310 311 312 // Return stable class name suitable for replay file. 313 const char *replay_name() const; 314 315 #ifdef ASSERT 316 bool debug_final_field_at(int offset); 317 bool debug_stable_field_at(int offset); 318 #endif 319 }; 320 321 #endif // SHARE_CI_CIINSTANCEKLASS_HPP