1 /* 2 * Copyright (c) 1999, 2023, 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 friend class CompileTrainingData; 48 49 private: 50 enum SubklassValue { subklass_unknown, subklass_false, subklass_true }; 51 52 jobject _loader; 53 jobject _protection_domain; 54 55 InstanceKlass::ClassState _init_state; // state of class 56 bool _is_shared; 57 bool _has_finalizer; 58 SubklassValue _has_subklass; 59 bool _has_nonstatic_fields; 60 bool _has_nonstatic_concrete_methods; 61 bool _is_hidden; 62 bool _is_record; 63 bool _has_trusted_loader; 64 65 ciFlags _flags; 66 67 // Lazy fields get filled in only upon request. 68 ciInstanceKlass* _super; 69 ciInstance* _java_mirror; 70 71 ciConstantPoolCache* _field_cache; // cached map index->field 72 GrowableArray<ciField*>* _nonstatic_fields; 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); 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 int compute_nonstatic_fields(); 113 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields); 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 static InstanceKlass::ClassState compute_init_state(InstanceKlass* ik); 124 125 public: 126 // Has this klass been initialized? 127 bool is_initialized() { 128 update_if_shared(InstanceKlass::fully_initialized); 129 return _init_state == InstanceKlass::fully_initialized; 130 } 131 bool is_not_initialized() { 132 update_if_shared(InstanceKlass::fully_initialized); 133 return _init_state < InstanceKlass::being_initialized; 134 } 135 // Is this klass being initialized? 136 bool is_being_initialized() { 137 update_if_shared(InstanceKlass::being_initialized); 138 return _init_state == InstanceKlass::being_initialized; 139 } 140 // Has this klass been linked? 141 bool is_linked() { 142 update_if_shared(InstanceKlass::linked); 143 return _init_state >= InstanceKlass::linked; 144 } 145 // Is this klass in error state? 146 bool is_in_error_state() { 147 update_if_shared(InstanceKlass::initialization_error); 148 return _init_state == InstanceKlass::initialization_error; 149 } 150 151 // General klass information. 152 ciFlags flags() { 153 assert(is_loaded(), "must be loaded"); 154 return _flags; 155 } 156 bool has_finalizer() { 157 assert(is_loaded(), "must be loaded"); 158 return _has_finalizer; } 159 bool has_subklass() { 160 assert(is_loaded(), "must be loaded"); 161 // Ignore cached subklass_false case. 162 // It could be invalidated by concurrent class loading and 163 // can result in type paradoxes during compilation when 164 // a subclass is observed, but has_subklass() returns false. 165 if (_has_subklass == subklass_true) { 166 return true; 167 } 168 if (flags().is_final()) { 169 return false; 170 } 171 return compute_shared_has_subklass(); 172 } 173 174 jint layout_helper_size_in_bytes() { 175 return Klass::layout_helper_size_in_bytes(layout_helper()); 176 } 177 jint size_helper() { 178 return (Klass::layout_helper_size_in_bytes(layout_helper()) 179 >> LogHeapWordSize); 180 } 181 jint has_nonstatic_fields() { 182 assert(is_loaded(), "must be loaded"); 183 return _has_nonstatic_fields; } 184 ciInstanceKlass* super(); 185 jint nof_implementors() { 186 ciInstanceKlass* impl; 187 assert(is_loaded(), "must be loaded"); 188 impl = implementor(); 189 if (impl == nullptr) { 190 return 0; 191 } else if (impl != this) { 192 return 1; 193 } else { 194 return 2; 195 } 196 } 197 bool has_nonstatic_concrete_methods() { 198 assert(is_loaded(), "must be loaded"); 199 return _has_nonstatic_concrete_methods; 200 } 201 202 bool is_hidden() const { 203 return _is_hidden; 204 } 205 206 bool is_record() const { 207 return _is_record; 208 } 209 210 ciInstanceKlass* get_canonical_holder(int offset); 211 ciField* get_field_by_offset(int field_offset, bool is_static); 212 ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static); 213 214 // total number of nonstatic fields (including inherited): 215 int nof_nonstatic_fields() { 216 if (_nonstatic_fields == nullptr) 217 return compute_nonstatic_fields(); 218 else 219 return _nonstatic_fields->length(); 220 } 221 222 bool has_injected_fields() { 223 if (_has_injected_fields == -1) { 224 compute_injected_fields(); 225 } 226 return _has_injected_fields > 0 ? true : false; 227 } 228 229 bool has_object_fields() const; 230 231 // nth nonstatic field (presented by ascending address) 232 ciField* nonstatic_field_at(int i) { 233 assert(_nonstatic_fields != nullptr, ""); 234 return _nonstatic_fields->at(i); 235 } 236 237 ciInstanceKlass* unique_concrete_subklass(); 238 bool has_finalizable_subclass(); 239 240 bool contains_field_offset(int offset); 241 242 // Get the instance of java.lang.Class corresponding to 243 // this klass. This instance is used for locking of 244 // synchronized static methods of this klass. 245 ciInstance* java_mirror(); 246 247 // Java access flags 248 bool is_public () { return flags().is_public(); } 249 bool is_final () { return flags().is_final(); } 250 bool is_super () { return flags().is_super(); } 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 : nullptr); 265 } 266 267 // Is the defining class loader of this class the default loader? 268 bool uses_default_loader() const; 269 270 bool is_java_lang_Object() const; 271 272 BasicType box_klass_type() const; 273 bool is_box_klass() const; 274 bool is_boxed_value_offset(int offset) const; 275 276 // Is this klass in the given package? 277 bool is_in_package(const char* packagename) { 278 return is_in_package(packagename, (int) strlen(packagename)); 279 } 280 bool is_in_package(const char* packagename, int len); 281 282 // What kind of ciObject is this? 283 bool is_instance_klass() const { return true; } 284 285 virtual ciKlass* exact_klass() { 286 if (is_loaded() && is_final() && !is_interface()) { 287 return this; 288 } 289 return nullptr; 290 } 291 292 bool can_be_instantiated() { 293 assert(is_loaded(), "must be loaded"); 294 return !is_interface() && !is_abstract(); 295 } 296 297 bool has_trusted_loader() const { 298 return _has_trusted_loader; 299 } 300 GrowableArray<ciInstanceKlass*>* transitive_interfaces() const; 301 302 // Replay support 303 304 // Dump the current state of this klass for compilation replay. 305 virtual void dump_replay_data(outputStream* out); 306 307 static void dump_replay_instanceKlass(outputStream* out, InstanceKlass* ik); 308 309 310 // Return stable class name suitable for replay file. 311 const char *replay_name() const; 312 313 #ifdef ASSERT 314 bool debug_final_field_at(int offset); 315 bool debug_stable_field_at(int offset); 316 #endif 317 }; 318 319 #endif // SHARE_CI_CIINSTANCEKLASS_HPP --- EOF ---