1128 allocate_mirror(k, /*is_scratch=*/false, protection_domain, classData, mirror, comp_mirror, CHECK);
1129
1130 // set the classLoader field in the java_lang_Class instance
1131 assert(class_loader() == k->class_loader(), "should be same");
1132 set_class_loader(mirror(), class_loader());
1133
1134 // Setup indirection from klass->mirror
1135 // after any exceptions can happen during allocations.
1136 k->set_java_mirror(mirror);
1137
1138 // Set the module field in the java_lang_Class instance. This must be done
1139 // after the mirror is set.
1140 set_mirror_module_field(THREAD, k, mirror, module);
1141
1142 if (comp_mirror() != nullptr) {
1143 // Set after k->java_mirror() is published, because compiled code running
1144 // concurrently doesn't expect a k to have a null java_mirror.
1145 release_set_array_klass(comp_mirror(), k);
1146 }
1147 if (CDSConfig::is_dumping_heap()) {
1148 create_scratch_mirror(k, CHECK);
1149 }
1150 } else {
1151 assert(fixup_mirror_list() != nullptr, "fixup_mirror_list not initialized");
1152 fixup_mirror_list()->push(k);
1153 }
1154 }
1155
1156 #if INCLUDE_CDS_JAVA_HEAP
1157 // The "scratch mirror" stores the states of the mirror object that can be
1158 // decided at dump time (such as the initial values of the static fields, the
1159 // component mirror, etc). At runtime, more information is added to it by
1160 // java_lang_Class::restore_archived_mirror().
1161 //
1162 // Essentially, /*dumptime*/create_scratch_mirror() + /*runtime*/restore_archived_mirror()
1163 // produces the same result as /*runtime*/create_mirror().
1164 //
1165 // Note: we archive the "scratch mirror" instead of k->java_mirror(), because the
1166 // latter may contain dumptime-specific information that cannot be archived
1167 // (e.g., ClassLoaderData*, or static fields that are modified by Java code execution).
1168 void java_lang_Class::create_scratch_mirror(Klass* k, TRAPS) {
1169 if (k->class_loader() != nullptr &&
1170 k->class_loader() != SystemDictionary::java_platform_loader() &&
1171 k->class_loader() != SystemDictionary::java_system_loader()) {
1172 // We only archive the mirrors of classes loaded by the built-in loaders
1173 return;
1174 }
1175
1176 Handle protection_domain, classData; // set to null. Will be reinitialized at runtime
1177 Handle mirror;
1178 Handle comp_mirror;
1179 allocate_mirror(k, /*is_scratch=*/true, protection_domain, classData, mirror, comp_mirror, CHECK);
1180
1181 if (comp_mirror() != nullptr) {
1182 release_set_array_klass(comp_mirror(), k);
1183 }
1184
1185 HeapShared::set_scratch_java_mirror(k, mirror());
1186 }
1187
1188 // Returns true if the mirror is updated, false if no archived mirror
1189 // data is present. After the archived mirror object is restored, the
1190 // shared klass' _has_raw_archived_mirror flag is cleared.
1191 bool java_lang_Class::restore_archived_mirror(Klass *k,
1192 Handle class_loader, Handle module,
1193 Handle protection_domain, TRAPS) {
1194 // Postpone restoring archived mirror until java.lang.Class is loaded. Please
1195 // see more details in vmClasses::resolve_all().
1196 if (!vmClasses::Class_klass_loaded()) {
1290 }
1291 void java_lang_Class::set_init_lock(oop java_class, oop init_lock) {
1292 assert(_init_lock_offset != 0, "must be set");
1293 java_class->obj_field_put(_init_lock_offset, init_lock);
1294 }
1295
1296 objArrayOop java_lang_Class::signers(oop java_class) {
1297 assert(_signers_offset != 0, "must be set");
1298 return (objArrayOop)java_class->obj_field(_signers_offset);
1299 }
1300
1301 oop java_lang_Class::class_data(oop java_class) {
1302 assert(_classData_offset != 0, "must be set");
1303 return java_class->obj_field(_classData_offset);
1304 }
1305 void java_lang_Class::set_class_data(oop java_class, oop class_data) {
1306 assert(_classData_offset != 0, "must be set");
1307 java_class->obj_field_put(_classData_offset, class_data);
1308 }
1309
1310 void java_lang_Class::set_reflection_data(oop java_class, oop reflection_data) {
1311 assert(_reflectionData_offset != 0, "must be set");
1312 java_class->obj_field_put(_reflectionData_offset, reflection_data);
1313 }
1314
1315 void java_lang_Class::set_class_loader(oop java_class, oop loader) {
1316 assert(_class_loader_offset != 0, "offsets should have been initialized");
1317 java_class->obj_field_put(_class_loader_offset, loader);
1318 }
1319
1320 oop java_lang_Class::class_loader(oop java_class) {
1321 assert(_class_loader_offset != 0, "must be set");
1322 return java_class->obj_field(_class_loader_offset);
1323 }
1324
1325 oop java_lang_Class::module(oop java_class) {
1326 assert(_module_offset != 0, "must be set");
1327 return java_class->obj_field(_module_offset);
1328 }
1329
1492 (*reference_klass) = as_Klass(java_class);
1493 return T_OBJECT;
1494 }
1495 }
1496
1497
1498 oop java_lang_Class::primitive_mirror(BasicType t) {
1499 oop mirror = Universe::java_mirror(t);
1500 assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
1501 assert(is_primitive(mirror), "must be primitive");
1502 return mirror;
1503 }
1504
1505 #define CLASS_FIELDS_DO(macro) \
1506 macro(_classRedefinedCount_offset, k, "classRedefinedCount", int_signature, false); \
1507 macro(_class_loader_offset, k, "classLoader", classloader_signature, false); \
1508 macro(_component_mirror_offset, k, "componentType", class_signature, false); \
1509 macro(_module_offset, k, "module", module_signature, false); \
1510 macro(_name_offset, k, "name", string_signature, false); \
1511 macro(_classData_offset, k, "classData", object_signature, false); \
1512 macro(_reflectionData_offset, k, "reflectionData", java_lang_ref_SoftReference_signature, false); \
1513 macro(_signers_offset, k, "signers", object_array_signature, false); \
1514 macro(_modifiers_offset, k, vmSymbols::modifiers_name(), char_signature, false); \
1515 macro(_protection_domain_offset, k, "protectionDomain", java_security_ProtectionDomain_signature, false); \
1516 macro(_is_primitive_offset, k, "primitive", bool_signature, false);
1517
1518 void java_lang_Class::compute_offsets() {
1519 if (_offsets_computed) {
1520 return;
1521 }
1522
1523 _offsets_computed = true;
1524
1525 InstanceKlass* k = vmClasses::Class_klass();
1526 CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1527 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1528 }
1529
1530 #if INCLUDE_CDS
1531 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1532 f->do_bool(&_offsets_computed);
2301 return msg_utf8;
2302 }
2303
2304 oop java_lang_Throwable::cause(oop throwable) {
2305 return throwable->obj_field(_cause_offset);
2306 }
2307
2308 void java_lang_Throwable::set_message(oop throwable, oop value) {
2309 throwable->obj_field_put(_detailMessage_offset, value);
2310 }
2311
2312
2313 void java_lang_Throwable::set_stacktrace(oop throwable, oop st_element_array) {
2314 throwable->obj_field_put(_stackTrace_offset, st_element_array);
2315 }
2316
2317 void java_lang_Throwable::clear_stacktrace(oop throwable) {
2318 set_stacktrace(throwable, nullptr);
2319 }
2320
2321
2322 void java_lang_Throwable::print(oop throwable, outputStream* st) {
2323 ResourceMark rm;
2324 Klass* k = throwable->klass();
2325 assert(k != nullptr, "just checking");
2326 st->print("%s", k->external_name());
2327 oop msg = message(throwable);
2328 if (msg != nullptr) {
2329 st->print(": %s", java_lang_String::as_utf8_string(msg));
2330 }
2331 }
2332
2333 // After this many redefines, the stack trace is unreliable.
2334 const int MAX_VERSION = USHRT_MAX;
2335
2336 static inline bool version_matches(Method* method, int version) {
2337 assert(version < MAX_VERSION, "version is too big");
2338 return method != nullptr && (method->constants()->version() == version);
2339 }
2340
|
1128 allocate_mirror(k, /*is_scratch=*/false, protection_domain, classData, mirror, comp_mirror, CHECK);
1129
1130 // set the classLoader field in the java_lang_Class instance
1131 assert(class_loader() == k->class_loader(), "should be same");
1132 set_class_loader(mirror(), class_loader());
1133
1134 // Setup indirection from klass->mirror
1135 // after any exceptions can happen during allocations.
1136 k->set_java_mirror(mirror);
1137
1138 // Set the module field in the java_lang_Class instance. This must be done
1139 // after the mirror is set.
1140 set_mirror_module_field(THREAD, k, mirror, module);
1141
1142 if (comp_mirror() != nullptr) {
1143 // Set after k->java_mirror() is published, because compiled code running
1144 // concurrently doesn't expect a k to have a null java_mirror.
1145 release_set_array_klass(comp_mirror(), k);
1146 }
1147 if (CDSConfig::is_dumping_heap()) {
1148 if (CDSConfig::is_dumping_protection_domains()) {
1149 create_scratch_mirror(k, protection_domain, CHECK);
1150 } else {
1151 create_scratch_mirror(k, Handle() /* null protection_domain*/, CHECK);
1152 }
1153 }
1154 } else {
1155 assert(fixup_mirror_list() != nullptr, "fixup_mirror_list not initialized");
1156 fixup_mirror_list()->push(k);
1157 }
1158 }
1159
1160 #if INCLUDE_CDS_JAVA_HEAP
1161 // The "scratch mirror" stores the states of the mirror object that can be
1162 // decided at dump time (such as the initial values of the static fields, the
1163 // component mirror, etc). At runtime, more information is added to it by
1164 // java_lang_Class::restore_archived_mirror().
1165 //
1166 // Essentially, /*dumptime*/create_scratch_mirror() + /*runtime*/restore_archived_mirror()
1167 // produces the same result as /*runtime*/create_mirror().
1168 //
1169 // Note: we archive the "scratch mirror" instead of k->java_mirror(), because the
1170 // latter may contain dumptime-specific information that cannot be archived
1171 // (e.g., ClassLoaderData*, or static fields that are modified by Java code execution).
1172 void java_lang_Class::create_scratch_mirror(Klass* k, Handle protection_domain, TRAPS) {
1173 if (k->class_loader() != nullptr &&
1174 k->class_loader() != SystemDictionary::java_platform_loader() &&
1175 k->class_loader() != SystemDictionary::java_system_loader()) {
1176 // We only archive the mirrors of classes loaded by the built-in loaders
1177 return;
1178 }
1179
1180 Handle classData; // set to null. Will be reinitialized at runtime
1181 Handle mirror;
1182 Handle comp_mirror;
1183 allocate_mirror(k, /*is_scratch=*/true, protection_domain, classData, mirror, comp_mirror, CHECK);
1184
1185 if (comp_mirror() != nullptr) {
1186 release_set_array_klass(comp_mirror(), k);
1187 }
1188
1189 HeapShared::set_scratch_java_mirror(k, mirror());
1190 }
1191
1192 // Returns true if the mirror is updated, false if no archived mirror
1193 // data is present. After the archived mirror object is restored, the
1194 // shared klass' _has_raw_archived_mirror flag is cleared.
1195 bool java_lang_Class::restore_archived_mirror(Klass *k,
1196 Handle class_loader, Handle module,
1197 Handle protection_domain, TRAPS) {
1198 // Postpone restoring archived mirror until java.lang.Class is loaded. Please
1199 // see more details in vmClasses::resolve_all().
1200 if (!vmClasses::Class_klass_loaded()) {
1294 }
1295 void java_lang_Class::set_init_lock(oop java_class, oop init_lock) {
1296 assert(_init_lock_offset != 0, "must be set");
1297 java_class->obj_field_put(_init_lock_offset, init_lock);
1298 }
1299
1300 objArrayOop java_lang_Class::signers(oop java_class) {
1301 assert(_signers_offset != 0, "must be set");
1302 return (objArrayOop)java_class->obj_field(_signers_offset);
1303 }
1304
1305 oop java_lang_Class::class_data(oop java_class) {
1306 assert(_classData_offset != 0, "must be set");
1307 return java_class->obj_field(_classData_offset);
1308 }
1309 void java_lang_Class::set_class_data(oop java_class, oop class_data) {
1310 assert(_classData_offset != 0, "must be set");
1311 java_class->obj_field_put(_classData_offset, class_data);
1312 }
1313
1314 oop java_lang_Class::reflection_data(oop java_class) {
1315 assert(_reflectionData_offset != 0, "must be set");
1316 return java_class->obj_field(_reflectionData_offset);
1317 }
1318
1319 bool java_lang_Class::has_reflection_data(oop java_class) {
1320 return (java_lang_Class::reflection_data(java_class) != nullptr);
1321 }
1322
1323 void java_lang_Class::set_reflection_data(oop java_class, oop reflection_data) {
1324 assert(_reflectionData_offset != 0, "must be set");
1325 java_class->obj_field_put(_reflectionData_offset, reflection_data);
1326 }
1327
1328 void java_lang_Class::set_class_loader(oop java_class, oop loader) {
1329 assert(_class_loader_offset != 0, "offsets should have been initialized");
1330 java_class->obj_field_put(_class_loader_offset, loader);
1331 }
1332
1333 oop java_lang_Class::class_loader(oop java_class) {
1334 assert(_class_loader_offset != 0, "must be set");
1335 return java_class->obj_field(_class_loader_offset);
1336 }
1337
1338 oop java_lang_Class::module(oop java_class) {
1339 assert(_module_offset != 0, "must be set");
1340 return java_class->obj_field(_module_offset);
1341 }
1342
1505 (*reference_klass) = as_Klass(java_class);
1506 return T_OBJECT;
1507 }
1508 }
1509
1510
1511 oop java_lang_Class::primitive_mirror(BasicType t) {
1512 oop mirror = Universe::java_mirror(t);
1513 assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
1514 assert(is_primitive(mirror), "must be primitive");
1515 return mirror;
1516 }
1517
1518 #define CLASS_FIELDS_DO(macro) \
1519 macro(_classRedefinedCount_offset, k, "classRedefinedCount", int_signature, false); \
1520 macro(_class_loader_offset, k, "classLoader", classloader_signature, false); \
1521 macro(_component_mirror_offset, k, "componentType", class_signature, false); \
1522 macro(_module_offset, k, "module", module_signature, false); \
1523 macro(_name_offset, k, "name", string_signature, false); \
1524 macro(_classData_offset, k, "classData", object_signature, false); \
1525 macro(_reflectionData_offset, k, "reflectionData", class_ReflectionData_signature, false); \
1526 macro(_signers_offset, k, "signers", object_array_signature, false); \
1527 macro(_modifiers_offset, k, vmSymbols::modifiers_name(), char_signature, false); \
1528 macro(_protection_domain_offset, k, "protectionDomain", java_security_ProtectionDomain_signature, false); \
1529 macro(_is_primitive_offset, k, "primitive", bool_signature, false);
1530
1531 void java_lang_Class::compute_offsets() {
1532 if (_offsets_computed) {
1533 return;
1534 }
1535
1536 _offsets_computed = true;
1537
1538 InstanceKlass* k = vmClasses::Class_klass();
1539 CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1540 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1541 }
1542
1543 #if INCLUDE_CDS
1544 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1545 f->do_bool(&_offsets_computed);
2314 return msg_utf8;
2315 }
2316
2317 oop java_lang_Throwable::cause(oop throwable) {
2318 return throwable->obj_field(_cause_offset);
2319 }
2320
2321 void java_lang_Throwable::set_message(oop throwable, oop value) {
2322 throwable->obj_field_put(_detailMessage_offset, value);
2323 }
2324
2325
2326 void java_lang_Throwable::set_stacktrace(oop throwable, oop st_element_array) {
2327 throwable->obj_field_put(_stackTrace_offset, st_element_array);
2328 }
2329
2330 void java_lang_Throwable::clear_stacktrace(oop throwable) {
2331 set_stacktrace(throwable, nullptr);
2332 }
2333
2334 oop java_lang_Throwable::create_exception_instance(Symbol* class_name, TRAPS) {
2335 Klass* k = SystemDictionary::resolve_or_fail(class_name, true, CHECK_NULL);
2336 return InstanceKlass::cast(k)->allocate_instance(CHECK_NULL);
2337 }
2338
2339 void java_lang_Throwable::print(oop throwable, outputStream* st) {
2340 ResourceMark rm;
2341 Klass* k = throwable->klass();
2342 assert(k != nullptr, "just checking");
2343 st->print("%s", k->external_name());
2344 oop msg = message(throwable);
2345 if (msg != nullptr) {
2346 st->print(": %s", java_lang_String::as_utf8_string(msg));
2347 }
2348 }
2349
2350 // After this many redefines, the stack trace is unreliable.
2351 const int MAX_VERSION = USHRT_MAX;
2352
2353 static inline bool version_matches(Method* method, int version) {
2354 assert(version < MAX_VERSION, "version is too big");
2355 return method != nullptr && (method->constants()->version() == version);
2356 }
2357
|