1 /* 2 * Copyright (c) 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/archiveBuilder.hpp" 27 #include "cds/cdsConfig.hpp" 28 #include "cds/classPreinitializer.hpp" 29 #include "dumpTimeClassInfo.inline.hpp" 30 #include "cds/heapShared.hpp" 31 #include "classfile/systemDictionaryShared.hpp" 32 #include "memory/resourceArea.hpp" 33 #include "oops/fieldStreams.inline.hpp" 34 #include "oops/instanceKlass.inline.hpp" 35 #include "runtime/mutexLocker.hpp" 36 37 // Warning -- this is fragile!!! 38 // 39 // This is a hard-coded list of classes that are safe to preinitialize at dump time. It needs 40 // to be updated if the Java source code changes. 41 bool ClassPreinitializer::is_forced_preinit_class(InstanceKlass* ik) { 42 if (!CDSConfig::is_dumping_invokedynamic()) { 43 return false; 44 } 45 46 static const char* forced_preinit_classes[] = { 47 "java/util/HexFormat", 48 "jdk/internal/util/ClassFileDumper", 49 "java/lang/reflect/ClassFileFormatVersion", 50 "java/lang/Character$CharacterCache", 51 "java/lang/invoke/Invokers", 52 "java/lang/invoke/Invokers$Holder", 53 "java/lang/invoke/MethodHandle", 54 "java/lang/invoke/MethodHandleStatics", 55 "java/lang/invoke/DelegatingMethodHandle", 56 "java/lang/invoke/DelegatingMethodHandle$Holder", 57 "java/lang/invoke/LambdaForm", 58 "java/lang/invoke/LambdaForm$NamedFunction", 59 "java/lang/invoke/ClassSpecializer", 60 "java/lang/invoke/DirectMethodHandle", 61 "java/lang/invoke/DirectMethodHandle$Holder", 62 "java/lang/invoke/BoundMethodHandle$Specializer", 63 "java/lang/invoke/MethodHandles$Lookup", 64 65 //TODO: these use java.lang.ClassValue$Entry which is a subtype of WeakReference 66 //"java/lang/reflect/Proxy$ProxyBuilder", 67 //"java/lang/reflect/Proxy", 68 69 // TODO -- need to clear internTable, etc 70 //"java/lang/invoke/MethodType", 71 72 // TODO -- these need to link to native code 73 //"java/lang/invoke/BoundMethodHandle", 74 //"java/lang/invoke/BoundMethodHandle$Holder", 75 //"java/lang/invoke/MemberName", 76 //"java/lang/invoke/MethodHandleNatives", 77 }; 78 79 for (const char* class_name : forced_preinit_classes) { 80 if (ik->name()->equals(class_name)) { 81 if (log_is_enabled(Info, cds, init)) { 82 ResourceMark rm; 83 log_info(cds, init)("Force initialization %s", ik->external_name()); 84 } 85 return true; 86 } 87 } 88 89 return false; 90 } 91 92 // check_can_be_preinited() is quite costly, so we cache the results inside 93 // DumpTimeClassInfo::_can_be_preinited. See also ClassPreinitializer::reset_preinit_check(). 94 bool ClassPreinitializer::check_can_be_preinited(InstanceKlass* ik) { 95 ResourceMark rm; 96 97 if (!SystemDictionaryShared::is_builtin(ik)) { 98 log_info(cds, init)("cannot initialize %s (not built-in loader)", ik->external_name()); 99 return false; 100 } 101 102 InstanceKlass* super = ik->java_super(); 103 if (super != nullptr && !can_be_preinited_locked(super)) { 104 log_info(cds, init)("cannot initialize %s (super %s not initable)", ik->external_name(), super->external_name()); 105 return false; 106 } 107 108 Array<InstanceKlass*>* interfaces = ik->local_interfaces(); 109 for (int i = 0; i < interfaces->length(); i++) { 110 if (!can_be_preinited_locked(interfaces->at(i))) { 111 log_info(cds, init)("cannot initialize %s (interface %s not initable)", 112 ik->external_name(), interfaces->at(i)->external_name()); 113 return false; 114 } 115 } 116 117 if (HeapShared::is_lambda_form_klass(ik) || is_forced_preinit_class(ik)) { 118 // We allow only these to have <clinit> or non-default static fields 119 } else { 120 if (ik->class_initializer() != nullptr) { 121 log_info(cds, init)("cannot initialize %s (has <clinit>)", ik->external_name()); 122 return false; 123 } 124 if (ik->is_initialized() && !has_non_default_static_fields(ik)) { 125 return false; 126 } 127 } 128 129 return true; 130 } 131 132 bool ClassPreinitializer::has_non_default_static_fields(InstanceKlass* ik) { 133 oop mirror = ik->java_mirror(); 134 135 for (JavaFieldStream fs(ik); !fs.done(); fs.next()) { 136 if (fs.access_flags().is_static()) { 137 fieldDescriptor& fd = fs.field_descriptor(); 138 int offset = fd.offset(); 139 bool is_default = true; 140 bool has_initval = fd.has_initial_value(); 141 switch (fd.field_type()) { 142 case T_OBJECT: 143 case T_ARRAY: 144 is_default = mirror->obj_field(offset) == nullptr; 145 break; 146 case T_BOOLEAN: 147 is_default = mirror->bool_field(offset) == (has_initval ? fd.int_initial_value() : 0); 148 break; 149 case T_BYTE: 150 is_default = mirror->byte_field(offset) == (has_initval ? fd.int_initial_value() : 0); 151 break; 152 case T_SHORT: 153 is_default = mirror->short_field(offset) == (has_initval ? fd.int_initial_value() : 0); 154 break; 155 case T_CHAR: 156 is_default = mirror->char_field(offset) == (has_initval ? fd.int_initial_value() : 0); 157 break; 158 case T_INT: 159 is_default = mirror->int_field(offset) == (has_initval ? fd.int_initial_value() : 0); 160 break; 161 case T_LONG: 162 is_default = mirror->long_field(offset) == (has_initval ? fd.long_initial_value() : 0); 163 break; 164 case T_FLOAT: 165 is_default = mirror->float_field(offset) == (has_initval ? fd.float_initial_value() : 0); 166 break; 167 case T_DOUBLE: 168 is_default = mirror->double_field(offset) == (has_initval ? fd.double_initial_value() : 0); 169 break; 170 default: 171 ShouldNotReachHere(); 172 } 173 174 if (!is_default) { 175 log_info(cds, init)("cannot initialize %s (static field %s has non-default value)", 176 ik->external_name(), fd.name()->as_C_string()); 177 return false; 178 } 179 } 180 } 181 182 return true; 183 } 184 185 bool ClassPreinitializer::can_be_preinited(InstanceKlass* ik) { 186 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 187 return can_be_preinited_locked(ik); 188 } 189 190 bool ClassPreinitializer::can_be_preinited_locked(InstanceKlass* ik) { 191 if (!CDSConfig::is_initing_classes_at_dump_time()) { 192 return false; 193 } 194 195 assert_lock_strong(DumpTimeTable_lock); 196 DumpTimeClassInfo* info = SystemDictionaryShared::get_info_locked(ik); 197 if (!info->has_done_preinit_check()) { 198 info->set_can_be_preinited(ClassPreinitializer::check_can_be_preinited(ik)); 199 } 200 return info->can_be_preinited(); 201 } 202 203 // Initialize a class at dump time, if possible. 204 void ClassPreinitializer::maybe_preinit_class(InstanceKlass* ik, TRAPS) { 205 if (!ik->is_initialized() && ClassPreinitializer::can_be_preinited(ik)) { 206 if (log_is_enabled(Info, cds, init)) { 207 ResourceMark rm; 208 log_info(cds, init)("preinitializing %s", ik->external_name()); 209 } 210 ik->initialize(CHECK); 211 } 212 } 213 214 // ClassPreinitializer::can_be_preinited(ik) is called in two different phases: 215 // 216 // [1] Before the VM_PopulateDumpSharedSpace safepoint: 217 // when MetaspaceShared::link_shared_classes calls ClassPreinitializer::maybe_preinit_class(ik) 218 // [2] Inside the VM_PopulateDumpSharedSpace safepoint 219 // when HeapShared::archive_java_mirrors() calls ClassPreinitializer::can_archive_preinitialized_mirror(ik) 220 // 221 // Between the two phases, some Java code may have been executed to contaminate the 222 // some initialized mirrors. So we call reset_preinit_check() at the beginning of the 223 // [2] so that we will re-run has_non_default_static_fields() on all the classes. 224 // As a result, phase [2] may archive fewer mirrors that were initialized in phase [1]. 225 void ClassPreinitializer::reset_preinit_check() { 226 auto iterator = [&] (InstanceKlass* k, DumpTimeClassInfo& info) { 227 if (info.can_be_preinited()) { 228 info.reset_preinit_check(); 229 } 230 }; 231 SystemDictionaryShared::dumptime_table()->iterate_all_live_classes(iterator); 232 } 233 234 bool ClassPreinitializer::can_archive_preinitialized_mirror(InstanceKlass* ik) { 235 assert(!ArchiveBuilder::current()->is_in_buffer_space(ik), "must be source klass"); 236 if (!CDSConfig::is_initing_classes_at_dump_time()) { 237 return false; 238 } 239 240 if (ik->is_hidden()) { 241 return HeapShared::is_archivable_hidden_klass(ik); 242 } else { 243 return ClassPreinitializer::can_be_preinited_locked(ik); 244 } 245 }