1 /* 2 * Copyright (c) 2021, 2024, 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 "cds/cds_globals.hpp" 27 #include "cds/classListParser.hpp" 28 #include "cds/classListWriter.hpp" 29 #include "cds/classPrelinker.hpp" 30 #include "cds/lambdaFormInvokers.inline.hpp" 31 #include "classfile/classFileStream.hpp" 32 #include "classfile/classLoader.hpp" 33 #include "classfile/classLoaderData.hpp" 34 #include "classfile/classLoaderDataGraph.hpp" 35 #include "classfile/moduleEntry.hpp" 36 #include "classfile/symbolTable.hpp" 37 #include "classfile/systemDictionaryShared.hpp" 38 #include "memory/resourceArea.hpp" 39 #include "oops/constantPool.inline.hpp" 40 #include "oops/instanceKlass.hpp" 41 #include "runtime/javaCalls.hpp" 42 #include "runtime/mutexLocker.hpp" 43 44 fileStream* ClassListWriter::_classlist_file = nullptr; 45 46 void ClassListWriter::init() { 47 // For -XX:DumpLoadedClassList=<file> option 48 if (DumpLoadedClassList != nullptr) { 49 const char* list_name = make_log_name(DumpLoadedClassList, nullptr); 50 _classlist_file = new(mtInternal) 51 fileStream(list_name); 52 _classlist_file->print_cr("# NOTE: Do not modify this file."); 53 _classlist_file->print_cr("#"); 54 _classlist_file->print_cr("# This file is generated via the -XX:DumpLoadedClassList=<class_list_file> option"); 55 _classlist_file->print_cr("# and is used at CDS archive dump time (see -Xshare:dump)."); 56 _classlist_file->print_cr("#"); 57 FREE_C_HEAP_ARRAY(char, list_name); 58 } 59 } 60 61 void ClassListWriter::write(const InstanceKlass* k, const ClassFileStream* cfs) { 62 assert(is_enabled(), "must be"); 63 64 if (!ClassLoader::has_jrt_entry()) { 65 log_warning(cds)("DumpLoadedClassList and CDS are not supported in exploded build"); 66 DumpLoadedClassList = nullptr; 67 return; 68 } 69 70 ClassListWriter w; 71 write_to_stream(k, w.stream(), cfs); 72 } 73 74 class ClassListWriter::IDTable : public ResourceHashtable< 75 const InstanceKlass*, int, 76 15889, // prime number 77 AnyObj::C_HEAP> {}; 78 79 ClassListWriter::IDTable* ClassListWriter::_id_table = nullptr; 80 int ClassListWriter::_total_ids = 0; 81 82 int ClassListWriter::get_id(const InstanceKlass* k) { 83 assert_locked(); 84 if (_id_table == nullptr) { 85 _id_table = new (mtClass)IDTable(); 86 } 87 bool created; 88 int* v = _id_table->put_if_absent(k, &created); 89 if (created) { 90 *v = _total_ids++; 91 } 92 return *v; 93 } 94 95 bool ClassListWriter::has_id(const InstanceKlass* k) { 96 assert_locked(); 97 if (_id_table != nullptr) { 98 return _id_table->get(k) != nullptr; 99 } else { 100 return false; 101 } 102 } 103 104 void ClassListWriter::handle_class_unloading(const InstanceKlass* klass) { 105 assert_locked(); 106 if (_id_table != nullptr) { 107 _id_table->remove(klass); 108 } 109 } 110 111 void ClassListWriter::write_to_stream(const InstanceKlass* k, outputStream* stream, const ClassFileStream* cfs) { 112 assert_locked(); 113 114 ClassLoaderData* loader_data = k->class_loader_data(); 115 bool is_builtin_loader = SystemDictionaryShared::is_builtin_loader(loader_data); 116 if (!is_builtin_loader) { 117 // class may be loaded from shared archive 118 if (!k->is_shared()) { 119 if (cfs == nullptr || cfs->source() == nullptr) { 120 // CDS static dump only handles unregistered class with known source. 121 return; 122 } 123 if (strncmp(cfs->source(), "file:", 5) != 0) { 124 return; 125 } 126 } else { 127 // Shared unregistered classes are skipped since their real source are not recorded in shared space. 128 return; 129 } 130 if (!SystemDictionaryShared::add_unregistered_class(Thread::current(), (InstanceKlass*)k)) { 131 return; 132 } 133 } 134 135 if (cfs != nullptr && cfs->source() != nullptr) { 136 if (strcmp(cfs->source(), "_ClassSpecializer_generateConcreteSpeciesCode") == 0) { 137 return; 138 } 139 140 if (strncmp(cfs->source(), "__", 2) == 0) { 141 // generated class: __dynamic_proxy__, __JVM_LookupDefineClass__, etc 142 return; 143 } 144 } 145 146 { 147 InstanceKlass* super = k->java_super(); 148 if (super != nullptr && !has_id(super)) { 149 return; 150 } 151 152 Array<InstanceKlass*>* interfaces = k->local_interfaces(); 153 int len = interfaces->length(); 154 for (int i = 0; i < len; i++) { 155 InstanceKlass* intf = interfaces->at(i); 156 if (!has_id(intf)) { 157 return; 158 } 159 } 160 } 161 162 if (k->is_hidden()) { 163 return; 164 } 165 166 if (k->module()->is_patched()) { 167 return; 168 } 169 170 ResourceMark rm; 171 stream->print("%s id: %d", k->name()->as_C_string(), get_id(k)); 172 if (!is_builtin_loader) { 173 InstanceKlass* super = k->java_super(); 174 assert(super != nullptr, "must be"); 175 stream->print(" super: %d", get_id(super)); 176 177 Array<InstanceKlass*>* interfaces = k->local_interfaces(); 178 int len = interfaces->length(); 179 if (len > 0) { 180 stream->print(" interfaces:"); 181 for (int i = 0; i < len; i++) { 182 InstanceKlass* intf = interfaces->at(i); 183 stream->print(" %d", get_id(intf)); 184 } 185 } 186 187 #ifdef _WINDOWS 188 // "file:/C:/dir/foo.jar" -> "C:/dir/foo.jar" 189 stream->print(" source: %s", cfs->source() + 6); 190 #else 191 // "file:/dir/foo.jar" -> "/dir/foo.jar" 192 stream->print(" source: %s", cfs->source() + 5); 193 #endif 194 } 195 196 stream->cr(); 197 stream->flush(); 198 } 199 200 void ClassListWriter::delete_classlist() { 201 if (_classlist_file != nullptr) { 202 delete _classlist_file; 203 } 204 } 205 206 class ClassListWriter::WriteResolveConstantsCLDClosure : public CLDClosure { 207 public: 208 void do_cld(ClassLoaderData* cld) { 209 for (Klass* klass = cld->klasses(); klass != nullptr; klass = klass->next_link()) { 210 if (klass->is_instance_klass()) { 211 InstanceKlass* ik = InstanceKlass::cast(klass); 212 write_resolved_constants_for(ik); 213 write_array_info_for(ik); // FIXME: piggybacking on WriteResolveConstantsCLDClosure is misleading 214 } 215 } 216 } 217 }; 218 219 void ClassListWriter::write_array_info_for(InstanceKlass* ik) { 220 ObjArrayKlass* oak = ik->array_klasses(); 221 if (oak != nullptr) { 222 while (oak->higher_dimension() != nullptr) { 223 oak = oak->higher_dimension(); 224 } 225 ResourceMark rm; 226 outputStream* stream = _classlist_file; 227 stream->print_cr("%s %s %d", ClassListParser::ARRAY_TAG, ik->name()->as_C_string(), oak->dimension()); 228 } 229 } 230 231 void ClassListWriter::write_resolved_constants() { 232 if (!is_enabled()) { 233 return; 234 } 235 MutexLocker lock(ClassLoaderDataGraph_lock); 236 MutexLocker lock2(ClassListFile_lock, Mutex::_no_safepoint_check_flag); 237 238 WriteResolveConstantsCLDClosure closure; 239 ClassLoaderDataGraph::loaded_cld_do(&closure); 240 } 241 242 void ClassListWriter::write_reflection_data() { 243 if (!is_enabled()) { 244 return; 245 } 246 auto collector = [&] (const InstanceKlass* ik, int id) { 247 write_reflection_data_for(const_cast<InstanceKlass*>(ik)); 248 }; 249 _id_table->iterate_all(collector); 250 } 251 252 void ClassListWriter::write_reflection_data_for(InstanceKlass* ik) { 253 ResourceMark rm; 254 outputStream* stream = _classlist_file; 255 if (!SystemDictionaryShared::is_builtin_loader(ik->class_loader_data()) || ik->is_hidden()) { 256 return; // ignore 257 } 258 if (java_lang_Class::has_reflection_data(ik->java_mirror())) { 259 EXCEPTION_MARK; 260 int rd_flags = ClassPrelinker::class_reflection_data_flags(ik, THREAD); 261 if (!HAS_PENDING_EXCEPTION) { 262 // We can't hold the lock when doing the upcall inside class_reflection_data_flags() 263 MutexLocker lock2(ClassListFile_lock, Mutex::_no_safepoint_check_flag); 264 stream->print_cr("%s %s %d", ClassListParser::CLASS_REFLECTION_DATA_TAG, ik->name()->as_C_string(), rd_flags); 265 } 266 } 267 } 268 269 void ClassListWriter::write_resolved_constants_for(InstanceKlass* ik) { 270 if (!SystemDictionaryShared::is_builtin_loader(ik->class_loader_data()) || 271 ik->is_hidden()) { 272 return; 273 } 274 if (LambdaFormInvokers::may_be_regenerated_class(ik->name())) { 275 return; 276 } 277 if (ik->name()->equals("jdk/internal/module/SystemModules$all")) { 278 // This class is regenerated during JDK build process, so the classlist 279 // may not match the version that's in the real jdk image. 280 return; 281 } 282 283 if (!has_id(ik)) { // do not resolve CP for classes loaded by custom loaders. 284 return; 285 } 286 287 ResourceMark rm; 288 ConstantPool* cp = ik->constants(); 289 GrowableArray<bool> list(cp->length(), cp->length(), false); 290 bool print = false; 291 292 for (int cp_index = 1; cp_index < cp->length(); cp_index++) { // Index 0 is unused 293 switch (cp->tag_at(cp_index).value()) { 294 case JVM_CONSTANT_Class: 295 { 296 Klass* k = cp->resolved_klass_at(cp_index); 297 if (k->is_instance_klass()) { 298 list.at_put(cp_index, true); 299 print = true; 300 } 301 } 302 break; 303 } 304 } 305 306 if (cp->cache() != nullptr) { 307 Array<ResolvedIndyEntry>* indy_entries = cp->cache()->resolved_indy_entries(); 308 if (indy_entries != nullptr) { 309 for (int i = 0; i < indy_entries->length(); i++) { 310 ResolvedIndyEntry* rie = indy_entries->adr_at(i); 311 int cp_index = rie->constant_pool_index(); 312 if (rie->is_resolved()) { 313 list.at_put(cp_index, true); 314 print = true; 315 } 316 } 317 } 318 319 Array<ResolvedFieldEntry>* field_entries = cp->cache()->resolved_field_entries(); 320 if (field_entries != nullptr) { 321 for (int i = 0; i < field_entries->length(); i++) { 322 ResolvedFieldEntry* rfe = field_entries->adr_at(i); 323 if (rfe->is_resolved(Bytecodes::_getstatic) || 324 rfe->is_resolved(Bytecodes::_putstatic) || 325 rfe->is_resolved(Bytecodes::_getfield) || 326 rfe->is_resolved(Bytecodes::_putfield)) { 327 list.at_put(rfe->constant_pool_index(), true); 328 print = true; 329 } 330 } 331 } 332 333 Array<ResolvedMethodEntry>* method_entries = cp->cache()->resolved_method_entries(); 334 if (method_entries != nullptr) { 335 for (int i = 0; i < method_entries->length(); i++) { 336 ResolvedMethodEntry* rme = method_entries->adr_at(i); 337 if (rme->is_resolved(Bytecodes::_invokevirtual) || 338 rme->is_resolved(Bytecodes::_invokespecial) || 339 rme->is_resolved(Bytecodes::_invokeinterface) || 340 rme->is_resolved(Bytecodes::_invokestatic) || 341 rme->is_resolved(Bytecodes::_invokehandle)) { 342 list.at_put(rme->constant_pool_index(), true); 343 print = true; 344 } 345 } 346 } 347 } 348 349 if (print) { 350 outputStream* stream = _classlist_file; 351 stream->print("@cp %s", ik->name()->as_C_string()); 352 for (int i = 0; i < list.length(); i++) { 353 if (list.at(i)) { 354 constantTag cp_tag = cp->tag_at(i).value(); 355 assert(cp_tag.value() == JVM_CONSTANT_Class || 356 cp_tag.value() == JVM_CONSTANT_Fieldref || 357 cp_tag.value() == JVM_CONSTANT_Methodref|| 358 cp_tag.value() == JVM_CONSTANT_InterfaceMethodref || 359 cp_tag.value() == JVM_CONSTANT_InvokeDynamic, "sanity"); 360 stream->print(" %d", i); 361 } 362 } 363 stream->cr(); 364 } 365 } 366 367 void ClassListWriter::write_loader_negative_lookup_cache_for(oop loader, const char* loader_type) { 368 TempNewSymbol method = SymbolTable::new_symbol("negativeLookupCacheContents"); 369 TempNewSymbol signature = SymbolTable::new_symbol("()Ljava/lang/String;"); 370 371 EXCEPTION_MARK; 372 HandleMark hm(THREAD); 373 374 JavaValue result(T_OBJECT); 375 JavaCalls::call_virtual(&result, 376 Handle(THREAD, loader), 377 loader->klass(), 378 method, 379 signature, 380 CHECK); 381 382 if (HAS_PENDING_EXCEPTION) { 383 log_warning(cds)("Error during BuiltinClassLoader::negativeLookupCacheContents() call for %s loader", loader_type); 384 CLEAR_PENDING_EXCEPTION; 385 return; 386 } else if (result.get_oop() == nullptr) { 387 return; 388 } 389 390 ResourceMark rm; 391 const char* cache_contents = java_lang_String::as_utf8_string(result.get_oop()); 392 log_debug(cds)("%s loader negative cache: %s", loader_type, cache_contents); 393 394 outputStream* stream = _classlist_file; 395 const size_t buffer_size = strlen(ClassListParser::LOADER_NEGATIVE_CACHE_TAG) + 1 /* for space*/ 396 + strlen(loader_type) + 1 /* for space */ + strlen(cache_contents) + 1 /* for null character */; 397 char* buffer = NEW_C_HEAP_ARRAY(char, buffer_size, mtInternal); 398 _classlist_file->set_scratch_buffer(buffer, buffer_size); 399 MutexLocker lock2(ClassListFile_lock, Mutex::_no_safepoint_check_flag); 400 stream->print("%s %s %s", ClassListParser::LOADER_NEGATIVE_CACHE_TAG, loader_type, cache_contents); 401 stream->cr(); 402 _classlist_file->set_scratch_buffer(nullptr, 0); 403 } 404 405 void ClassListWriter::write_loader_negative_lookup_cache() { 406 if (!is_enabled()) { 407 return; 408 } 409 410 write_loader_negative_lookup_cache_for(SystemDictionary::java_platform_loader(), "platform"); 411 write_loader_negative_lookup_cache_for(SystemDictionary::java_system_loader(), "app"); 412 }