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/classListWriter.hpp" 28 #include "cds/lambdaFormInvokers.inline.hpp" 29 #include "classfile/classFileStream.hpp" 30 #include "classfile/classLoader.hpp" 31 #include "classfile/classLoaderData.hpp" 32 #include "classfile/classLoaderDataGraph.hpp" 33 #include "classfile/moduleEntry.hpp" 34 #include "classfile/systemDictionaryShared.hpp" 35 #include "memory/resourceArea.hpp" 36 #include "oops/constantPool.inline.hpp" 37 #include "oops/instanceKlass.hpp" 38 #include "runtime/mutexLocker.hpp" 39 40 fileStream* ClassListWriter::_classlist_file = nullptr; 41 42 void ClassListWriter::init() { 43 // For -XX:DumpLoadedClassList=<file> option 44 if (DumpLoadedClassList != nullptr) { 45 const char* list_name = make_log_name(DumpLoadedClassList, nullptr); 46 _classlist_file = new(mtInternal) 47 fileStream(list_name); 48 _classlist_file->print_cr("# NOTE: Do not modify this file."); 49 _classlist_file->print_cr("#"); 50 _classlist_file->print_cr("# This file is generated via the -XX:DumpLoadedClassList=<class_list_file> option"); 51 _classlist_file->print_cr("# and is used at CDS archive dump time (see -Xshare:dump)."); 52 _classlist_file->print_cr("#"); 53 FREE_C_HEAP_ARRAY(char, list_name); 54 } 55 } 56 57 void ClassListWriter::write(const InstanceKlass* k, const ClassFileStream* cfs) { 58 assert(is_enabled(), "must be"); 59 60 if (!ClassLoader::has_jrt_entry()) { 61 log_warning(cds)("DumpLoadedClassList and CDS are not supported in exploded build"); 62 DumpLoadedClassList = nullptr; 63 return; 64 } 65 66 ClassListWriter w; 67 write_to_stream(k, w.stream(), cfs); 68 } 69 70 class ClassListWriter::IDTable : public ResourceHashtable< 71 const InstanceKlass*, int, 72 15889, // prime number 73 AnyObj::C_HEAP> {}; 74 75 ClassListWriter::IDTable* ClassListWriter::_id_table = nullptr; 76 int ClassListWriter::_total_ids = 0; 77 78 int ClassListWriter::get_id(const InstanceKlass* k) { 79 assert_locked(); 80 if (_id_table == nullptr) { 81 _id_table = new (mtClass)IDTable(); 82 } 83 bool created; 84 int* v = _id_table->put_if_absent(k, &created); 85 if (created) { 86 *v = _total_ids++; 87 } 88 return *v; 89 } 90 91 bool ClassListWriter::has_id(const InstanceKlass* k) { 92 assert_locked(); 93 if (_id_table != nullptr) { 94 return _id_table->get(k) != nullptr; 95 } else { 96 return false; 97 } 98 } 99 100 void ClassListWriter::handle_class_unloading(const InstanceKlass* klass) { 101 assert_locked(); 102 if (_id_table != nullptr) { 103 _id_table->remove(klass); 104 } 105 } 106 107 void ClassListWriter::write_to_stream(const InstanceKlass* k, outputStream* stream, const ClassFileStream* cfs) { 108 assert_locked(); 109 110 ClassLoaderData* loader_data = k->class_loader_data(); 111 bool is_builtin_loader = SystemDictionaryShared::is_builtin_loader(loader_data); 112 if (!is_builtin_loader) { 113 // class may be loaded from shared archive 114 if (!k->is_shared()) { 115 if (cfs == nullptr || cfs->source() == nullptr) { 116 // CDS static dump only handles unregistered class with known source. 117 return; 118 } 119 if (strncmp(cfs->source(), "file:", 5) != 0) { 120 return; 121 } 122 } else { 123 // Shared unregistered classes are skipped since their real source are not recorded in shared space. 124 return; 125 } 126 if (!SystemDictionaryShared::add_unregistered_class(Thread::current(), (InstanceKlass*)k)) { 127 return; 128 } 129 } 130 131 // filter out java/lang/invoke/BoundMethodHandle$Species... 132 if (cfs != nullptr && cfs->source() != nullptr && strcmp(cfs->source(), "_ClassSpecializer_generateConcreteSpeciesCode") == 0) { 133 return; 134 } 135 136 { 137 InstanceKlass* super = k->java_super(); 138 if (super != nullptr && !has_id(super)) { 139 return; 140 } 141 142 Array<InstanceKlass*>* interfaces = k->local_interfaces(); 143 int len = interfaces->length(); 144 for (int i = 0; i < len; i++) { 145 InstanceKlass* intf = interfaces->at(i); 146 if (!has_id(intf)) { 147 return; 148 } 149 } 150 } 151 152 if (k->is_hidden()) { 153 return; 154 } 155 156 if (k->module()->is_patched()) { 157 return; 158 } 159 160 ResourceMark rm; 161 stream->print("%s id: %d", k->name()->as_C_string(), get_id(k)); 162 if (!is_builtin_loader) { 163 InstanceKlass* super = k->java_super(); 164 assert(super != nullptr, "must be"); 165 stream->print(" super: %d", get_id(super)); 166 167 Array<InstanceKlass*>* interfaces = k->local_interfaces(); 168 int len = interfaces->length(); 169 if (len > 0) { 170 stream->print(" interfaces:"); 171 for (int i = 0; i < len; i++) { 172 InstanceKlass* intf = interfaces->at(i); 173 stream->print(" %d", get_id(intf)); 174 } 175 } 176 177 #ifdef _WINDOWS 178 // "file:/C:/dir/foo.jar" -> "C:/dir/foo.jar" 179 stream->print(" source: %s", cfs->source() + 6); 180 #else 181 // "file:/dir/foo.jar" -> "/dir/foo.jar" 182 stream->print(" source: %s", cfs->source() + 5); 183 #endif 184 } 185 186 stream->cr(); 187 stream->flush(); 188 } 189 190 void ClassListWriter::delete_classlist() { 191 if (_classlist_file != nullptr) { 192 delete _classlist_file; 193 } 194 } 195 196 class ClassListWriter::WriteResolveConstantsCLDClosure : public CLDClosure { 197 public: 198 void do_cld(ClassLoaderData* cld) { 199 for (Klass* klass = cld->klasses(); klass != nullptr; klass = klass->next_link()) { 200 if (klass->is_instance_klass()) { 201 InstanceKlass* ik = InstanceKlass::cast(klass); 202 write_resolved_constants_for(ik); 203 } 204 } 205 } 206 }; 207 208 void ClassListWriter::write_resolved_constants() { 209 if (!is_enabled()) { 210 return; 211 } 212 MutexLocker lock(ClassLoaderDataGraph_lock); 213 MutexLocker lock2(ClassListFile_lock, Mutex::_no_safepoint_check_flag); 214 215 WriteResolveConstantsCLDClosure closure; 216 ClassLoaderDataGraph::loaded_cld_do(&closure); 217 } 218 219 void ClassListWriter::write_resolved_constants_for(InstanceKlass* ik) { 220 if (!SystemDictionaryShared::is_builtin_loader(ik->class_loader_data()) || 221 ik->is_hidden()) { 222 return; 223 } 224 if (LambdaFormInvokers::may_be_regenerated_class(ik->name())) { 225 return; 226 } 227 if (ik->name()->equals("jdk/internal/module/SystemModules$all")) { 228 // This class is regenerated during JDK build process, so the classlist 229 // may not match the version that's in the real jdk image. 230 return; 231 } 232 233 if (!has_id(ik)) { // do not resolve CP for classes loaded by custom loaders. 234 return; 235 } 236 237 ResourceMark rm; 238 ConstantPool* cp = ik->constants(); 239 GrowableArray<bool> list(cp->length(), cp->length(), false); 240 bool print = false; 241 242 for (int cp_index = 1; cp_index < cp->length(); cp_index++) { // Index 0 is unused 243 switch (cp->tag_at(cp_index).value()) { 244 case JVM_CONSTANT_Class: 245 { 246 Klass* k = cp->resolved_klass_at(cp_index); 247 if (k->is_instance_klass()) { 248 list.at_put(cp_index, true); 249 print = true; 250 } 251 } 252 break; 253 } 254 } 255 256 if (cp->cache() != nullptr) { 257 Array<ResolvedFieldEntry>* field_entries = cp->cache()->resolved_field_entries(); 258 if (field_entries != nullptr) { 259 for (int i = 0; i < field_entries->length(); i++) { 260 ResolvedFieldEntry* rfe = field_entries->adr_at(i); 261 if (rfe->is_resolved(Bytecodes::_getfield) || 262 rfe->is_resolved(Bytecodes::_putfield)) { 263 list.at_put(rfe->constant_pool_index(), true); 264 print = true; 265 } 266 } 267 } 268 269 Array<ResolvedMethodEntry>* method_entries = cp->cache()->resolved_method_entries(); 270 if (method_entries != nullptr) { 271 for (int i = 0; i < method_entries->length(); i++) { 272 ResolvedMethodEntry* rme = method_entries->adr_at(i); 273 if (rme->is_resolved(Bytecodes::_invokevirtual) || 274 rme->is_resolved(Bytecodes::_invokespecial) || 275 rme->is_resolved(Bytecodes::_invokeinterface)) { 276 list.at_put(rme->constant_pool_index(), true); 277 print = true; 278 } 279 } 280 } 281 } 282 283 if (print) { 284 outputStream* stream = _classlist_file; 285 stream->print("@cp %s", ik->name()->as_C_string()); 286 for (int i = 0; i < list.length(); i++) { 287 if (list.at(i)) { 288 constantTag cp_tag = cp->tag_at(i).value(); 289 assert(cp_tag.value() == JVM_CONSTANT_Class || 290 cp_tag.value() == JVM_CONSTANT_Fieldref || 291 cp_tag.value() == JVM_CONSTANT_Methodref|| 292 cp_tag.value() == JVM_CONSTANT_InterfaceMethodref, "sanity"); 293 stream->print(" %d", i); 294 } 295 } 296 stream->cr(); 297 } 298 }