35 #include "classfile/moduleEntry.hpp"
36 #include "classfile/stringTable.hpp"
37 #include "classfile/symbolTable.hpp"
38 #include "classfile/systemDictionary.hpp"
39 #include "classfile/vmClasses.hpp"
40 #include "classfile/vmSymbols.hpp"
41 #include "code/debugInfo.hpp"
42 #include "code/dependencyContext.hpp"
43 #include "code/pcDesc.hpp"
44 #include "gc/shared/collectedHeap.inline.hpp"
45 #include "interpreter/interpreter.hpp"
46 #include "interpreter/linkResolver.hpp"
47 #include "jvm.h"
48 #include "logging/log.hpp"
49 #include "logging/logStream.hpp"
50 #include "memory/oopFactory.hpp"
51 #include "memory/resourceArea.hpp"
52 #include "memory/universe.hpp"
53 #include "oops/fieldInfo.hpp"
54 #include "oops/fieldStreams.inline.hpp"
55 #include "oops/instanceKlass.inline.hpp"
56 #include "oops/instanceMirrorKlass.hpp"
57 #include "oops/klass.inline.hpp"
58 #include "oops/method.inline.hpp"
59 #include "oops/objArrayKlass.hpp"
60 #include "oops/objArrayOop.inline.hpp"
61 #include "oops/oop.inline.hpp"
62 #include "oops/oopCast.inline.hpp"
63 #include "oops/recordComponent.hpp"
64 #include "oops/symbol.hpp"
65 #include "oops/typeArrayOop.inline.hpp"
66 #include "prims/jvmtiExport.hpp"
67 #include "prims/methodHandles.hpp"
68 #include "prims/resolvedMethodTable.hpp"
69 #include "runtime/continuationEntry.inline.hpp"
70 #include "runtime/continuationJavaClasses.inline.hpp"
71 #include "runtime/fieldDescriptor.inline.hpp"
72 #include "runtime/frame.inline.hpp"
73 #include "runtime/handles.inline.hpp"
74 #include "runtime/handshake.hpp"
75 #include "runtime/init.hpp"
76 #include "runtime/interfaceSupport.inline.hpp"
851
852 // java_lang_Class
853
854 int java_lang_Class::_klass_offset;
855 int java_lang_Class::_array_klass_offset;
856 int java_lang_Class::_oop_size_offset;
857 int java_lang_Class::_static_oop_field_count_offset;
858 int java_lang_Class::_class_loader_offset;
859 int java_lang_Class::_module_offset;
860 int java_lang_Class::_protection_domain_offset;
861 int java_lang_Class::_component_mirror_offset;
862 int java_lang_Class::_init_lock_offset;
863 int java_lang_Class::_signers_offset;
864 int java_lang_Class::_name_offset;
865 int java_lang_Class::_source_file_offset;
866 int java_lang_Class::_classData_offset;
867 int java_lang_Class::_classRedefinedCount_offset;
868 int java_lang_Class::_reflectionData_offset;
869 int java_lang_Class::_modifiers_offset;
870 int java_lang_Class::_is_primitive_offset;
871 int java_lang_Class::_raw_access_flags_offset;
872
873 bool java_lang_Class::_offsets_computed = false;
874 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = nullptr;
875 GrowableArray<Klass*>* java_lang_Class::_fixup_module_field_list = nullptr;
876
877 #ifdef ASSERT
878 inline static void assert_valid_static_string_field(fieldDescriptor* fd) {
879 assert(fd->has_initial_value(), "caller should have checked this");
880 assert(fd->field_type() == T_OBJECT, "caller should have checked this");
881 assert(fd->signature() == vmSymbols::string_signature(), "just checking");
882 }
883 #endif
884
885 static void initialize_static_string_field(fieldDescriptor* fd, Handle mirror, TRAPS) {
886 DEBUG_ONLY(assert_valid_static_string_field(fd);)
887 oop string = fd->string_initial_value(CHECK);
888 mirror()->obj_field_put(fd->offset(), string);
889 }
890
1074 // With AOT-linked classes, java.base module is defined before any class
1075 // is loaded, so there's no need for fixup_module_field_list().
1076 GrowableArray<Klass*>* module_list =
1077 new (mtModule) GrowableArray<Klass*>(500, mtModule);
1078 set_fixup_module_field_list(module_list);
1079 }
1080 }
1081
1082 void java_lang_Class::allocate_mirror(Klass* k, bool is_scratch, Handle protection_domain, Handle classData,
1083 Handle& mirror, Handle& comp_mirror, TRAPS) {
1084 // Allocate mirror (java.lang.Class instance)
1085 oop mirror_oop = InstanceMirrorKlass::cast(vmClasses::Class_klass())->allocate_instance(k, CHECK);
1086 mirror = Handle(THREAD, mirror_oop);
1087
1088 // Setup indirection from mirror->klass
1089 set_klass(mirror(), k);
1090
1091 // Set the modifiers flag.
1092 u2 computed_modifiers = k->compute_modifier_flags();
1093 set_modifiers(mirror(), computed_modifiers);
1094
1095 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
1096 assert(oop_size(mirror()) == mk->instance_size(k), "should have been set");
1097
1098 set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
1099
1100 // It might also have a component mirror. This mirror must already exist.
1101 if (k->is_array_klass()) {
1102 // The Java code for array classes gets the access flags from the element type.
1103 set_raw_access_flags(mirror(), 0);
1104 if (k->is_typeArray_klass()) {
1105 BasicType type = TypeArrayKlass::cast(k)->element_type();
1106 if (is_scratch) {
1107 comp_mirror = Handle(THREAD, HeapShared::scratch_java_mirror(type));
1108 } else {
1109 comp_mirror = Handle(THREAD, Universe::java_mirror(type));
1110 }
1111 } else {
1112 assert(k->is_objArray_klass(), "Must be");
1113 Klass* element_klass = ObjArrayKlass::cast(k)->element_klass();
1114 assert(element_klass != nullptr, "Must have an element klass");
1115 if (is_scratch) {
1116 comp_mirror = Handle(THREAD, HeapShared::scratch_java_mirror(element_klass));
1117 } else {
1118 comp_mirror = Handle(THREAD, element_klass->java_mirror());
1119 }
1120 }
1121 assert(comp_mirror() != nullptr, "must have a mirror");
1122
1123 // Two-way link between the array klass and its component mirror:
1124 // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
1125 set_component_mirror(mirror(), comp_mirror());
1126 // See below for ordering dependencies between field array_klass in component mirror
1127 // and java_mirror in this klass.
1128 } else {
1129 assert(k->is_instance_klass(), "Must be");
1130 // Set the raw access_flags, this is used by reflection instead of modifier flags.
1131 set_raw_access_flags(mirror(), InstanceKlass::cast(k)->access_flags().as_unsigned_short());
1132 initialize_mirror_fields(InstanceKlass::cast(k), mirror, protection_domain, classData, THREAD);
1133 if (HAS_PENDING_EXCEPTION) {
1134 // If any of the fields throws an exception like OOM remove the klass field
1135 // from the mirror so GC doesn't follow it after the klass has been deallocated.
1136 // This mirror looks like a primitive type, which logically it is because it
1137 // it represents no class.
1138 set_klass(mirror(), nullptr);
1139 return;
1140 }
1141 }
1142 }
1143
1144 void java_lang_Class::create_mirror(Klass* k, Handle class_loader,
1145 Handle module, Handle protection_domain,
1146 Handle classData, TRAPS) {
1147 assert(k != nullptr, "Use create_basic_type_mirror for primitive types");
1148 assert(k->java_mirror() == nullptr, "should only assign mirror once");
1149
1150 // Class_klass has to be loaded because it is used to allocate
1151 // the mirror.
1152 if (vmClasses::Class_klass_is_loaded()) {
1153 Handle mirror;
1154 Handle comp_mirror;
1155
1156 allocate_mirror(k, /*is_scratch=*/false, protection_domain, classData, mirror, comp_mirror, CHECK);
1157
1158 // set the classLoader field in the java_lang_Class instance
1159 assert(class_loader() == k->class_loader(), "should be same");
1160 set_class_loader(mirror(), class_loader());
1161
1162 // Setup indirection from klass->mirror
1163 // after any exceptions can happen during allocations.
1164 k->set_java_mirror(mirror);
1165
1166 // Set the module field in the java_lang_Class instance. This must be done
1167 // after the mirror is set.
1168 set_mirror_module_field(THREAD, k, mirror, module);
1169
1170 if (comp_mirror() != nullptr) {
1171 // Set after k->java_mirror() is published, because compiled code running
1172 // concurrently doesn't expect a k to have a null java_mirror.
1173 release_set_array_klass(comp_mirror(), k);
1174 }
1175 if (CDSConfig::is_dumping_heap()) {
1176 create_scratch_mirror(k, CHECK);
1177 }
1178 } else {
1179 assert(!CDSConfig::is_using_aot_linked_classes(), "should not come here");
1180 assert(fixup_mirror_list() != nullptr, "fixup_mirror_list not initialized");
1181 fixup_mirror_list()->push(k);
1182 }
1183 }
1184
1185 #if INCLUDE_CDS_JAVA_HEAP
1186 // The "scratch mirror" stores the states of the mirror object that can be
1187 // decided at dump time (such as the initial values of the static fields, the
1188 // component mirror, etc). At runtime, more information is added to it by
1189 // java_lang_Class::restore_archived_mirror().
1190 //
1191 // Essentially, /*dumptime*/create_scratch_mirror() + /*runtime*/restore_archived_mirror()
1192 // produces the same result as /*runtime*/create_mirror().
1193 //
1194 // Note: we archive the "scratch mirror" instead of k->java_mirror(), because the
1195 // latter may contain dumptime-specific information that cannot be archived
1196 // (e.g., ClassLoaderData*, or static fields that are modified by Java code execution).
1197 void java_lang_Class::create_scratch_mirror(Klass* k, TRAPS) {
1198 if (k->class_loader() != nullptr &&
1199 k->class_loader() != SystemDictionary::java_platform_loader() &&
1200 k->class_loader() != SystemDictionary::java_system_loader()) {
1201 // We only archive the mirrors of classes loaded by the built-in loaders
1202 return;
1203 }
1204
1205 Handle protection_domain, classData; // set to null. Will be reinitialized at runtime
1206 Handle mirror;
1207 Handle comp_mirror;
1208 allocate_mirror(k, /*is_scratch=*/true, protection_domain, classData, mirror, comp_mirror, CHECK);
1209
1210 if (comp_mirror() != nullptr) {
1211 release_set_array_klass(comp_mirror(), k);
1212 }
1213
1214 HeapShared::set_scratch_java_mirror(k, mirror());
1215 }
1216
1217 // Returns true if the mirror is updated, false if no archived mirror
1218 // data is present. After the archived mirror object is restored, the
1219 // shared klass' _has_raw_archived_mirror flag is cleared.
1220 bool java_lang_Class::restore_archived_mirror(Klass *k,
1221 Handle class_loader, Handle module,
1222 Handle protection_domain, TRAPS) {
1223 // Postpone restoring archived mirror until java.lang.Class is loaded. Please
1224 // see more details in vmClasses::resolve_all().
1225 if (!vmClasses::Class_klass_is_loaded() && !CDSConfig::is_using_aot_linked_classes()) {
1226 assert(fixup_mirror_list() != nullptr, "fixup_mirror_list not initialized");
1227 fixup_mirror_list()->push(k);
1228 return true;
1229 }
1230
1231 oop m = k->archived_java_mirror();
1232 assert(m != nullptr, "must have stored non-null archived mirror");
1233
1234 // Sanity: clear it now to prevent re-initialization if any of the following fails
1235 k->clear_archived_mirror_index();
1236
1237 // mirror is archived, restore
1238 log_debug(aot, mirror)("Archived mirror is: " PTR_FORMAT, p2i(m));
1239 assert(as_Klass(m) == k, "must be");
1240 Handle mirror(THREAD, m);
1241
1242 if (!k->is_array_klass()) {
1243 // - local static final fields with initial values were initialized at dump time
1244 assert(init_lock(mirror()) != nullptr, "allocated during AOT assembly");
1245
1246 if (protection_domain.not_null()) {
1247 set_protection_domain(mirror(), protection_domain());
1248 }
1249 }
1250
1251 assert(class_loader() == k->class_loader(), "should be same");
1252 if (class_loader.not_null()) {
1253 set_class_loader(mirror(), class_loader());
1254 }
1255
1256 k->set_java_mirror(mirror);
1257
1258 set_mirror_module_field(THREAD, k, mirror, module);
1259
1260 if (log_is_enabled(Trace, aot, heap, mirror)) {
1261 ResourceMark rm(THREAD);
1262 log_trace(aot, heap, mirror)(
1263 "Restored %s archived mirror " PTR_FORMAT, k->external_name(), p2i(mirror()));
1264 }
1265
1266 if (CDSConfig::is_dumping_heap()) {
1267 create_scratch_mirror(k, CHECK_(false));
1268 }
1269
1270 return true;
1271 }
1272 #endif // INCLUDE_CDS_JAVA_HEAP
1273
1274 void java_lang_Class::fixup_module_field(Klass* k, Handle module) {
1275 assert(_module_offset != 0, "must have been computed already");
1276 set_module(k->java_mirror(), module());
1277 }
1278
1279 void java_lang_Class::set_oop_size(HeapWord* java_class, size_t size) {
1280 assert(_oop_size_offset != 0, "must be set");
1281 assert(size > 0, "Oop size must be greater than zero, not %zu", size);
1282 assert(size <= INT_MAX, "Lossy conversion: %zu", size);
1283 *(int*)(((char*)java_class) + _oop_size_offset) = (int)size;
1284 }
1285
1286 int java_lang_Class::static_oop_field_count(oop java_class) {
1365 java_class->obj_field_put(_name_offset, o);
1366 }
1367 return o;
1368 }
1369
1370 oop java_lang_Class::source_file(oop java_class) {
1371 assert(_source_file_offset != 0, "must be set");
1372 return java_class->obj_field(_source_file_offset);
1373 }
1374
1375 void java_lang_Class::set_source_file(oop java_class, oop source_file) {
1376 assert(_source_file_offset != 0, "must be set");
1377 java_class->obj_field_put(_source_file_offset, source_file);
1378 }
1379
1380 void java_lang_Class::set_is_primitive(oop java_class) {
1381 assert(_is_primitive_offset != 0, "must be set");
1382 java_class->bool_field_put(_is_primitive_offset, true);
1383 }
1384
1385
1386 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
1387 // Mirrors for basic types have a null klass field, which makes them special.
1388 oop java_class = InstanceMirrorKlass::cast(vmClasses::Class_klass())->allocate_instance(nullptr, CHECK_NULL);
1389 if (type != T_VOID) {
1390 Klass* aklass = Universe::typeArrayKlass(type);
1391 assert(aklass != nullptr, "correct bootstrap");
1392 release_set_array_klass(java_class, aklass);
1393 }
1394 #ifdef ASSERT
1395 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(vmClasses::Class_klass());
1396 assert(static_oop_field_count(java_class) == 0, "should have been zeroed by allocation");
1397 #endif
1398 set_modifiers(java_class, JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
1399 set_raw_access_flags(java_class, JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
1400
1401 set_is_primitive(java_class);
1402 return java_class;
1403 }
1404
1406 assert(is_instance(java_class), "must be a Class object");
1407 java_class->metadata_field_put(_klass_offset, klass);
1408 }
1409
1410
1411 void java_lang_Class::print_signature(oop java_class, outputStream* st) {
1412 assert(is_instance(java_class), "must be a Class object");
1413 Symbol* name = nullptr;
1414 bool is_instance = false;
1415 if (is_primitive(java_class)) {
1416 name = vmSymbols::type_signature(primitive_type(java_class));
1417 } else {
1418 Klass* k = as_Klass(java_class);
1419 is_instance = k->is_instance_klass();
1420 name = k->name();
1421 }
1422 if (name == nullptr) {
1423 st->print("<null>");
1424 return;
1425 }
1426 if (is_instance) st->print("L");
1427 st->write((char*) name->base(), (int) name->utf8_length());
1428 if (is_instance) st->print(";");
1429 }
1430
1431 Symbol* java_lang_Class::as_signature(oop java_class, bool intern_if_not_found) {
1432 assert(is_instance(java_class), "must be a Class object");
1433 Symbol* name;
1434 if (is_primitive(java_class)) {
1435 name = vmSymbols::type_signature(primitive_type(java_class));
1436 // Because this can create a new symbol, the caller has to decrement
1437 // the refcount, so make adjustment here and below for symbols returned
1438 // that are not created or incremented due to a successful lookup.
1439 name->increment_refcount();
1440 } else {
1441 Klass* k = as_Klass(java_class);
1442 if (!k->is_instance_klass()) {
1443 name = k->name();
1444 name->increment_refcount();
1445 } else {
1446 ResourceMark rm;
1464 const char* name = nullptr;
1465 if (is_primitive(java_class)) {
1466 name = type2name(primitive_type(java_class));
1467 } else {
1468 name = as_Klass(java_class)->external_name();
1469 }
1470 if (name == nullptr) {
1471 name = "<null>";
1472 }
1473 return name;
1474 }
1475
1476 Klass* java_lang_Class::array_klass_acquire(oop java_class) {
1477 Klass* k = ((Klass*)java_class->metadata_field_acquire(_array_klass_offset));
1478 assert(k == nullptr || (k->is_klass() && k->is_array_klass()), "should be array klass");
1479 return k;
1480 }
1481
1482 void java_lang_Class::release_set_array_klass(oop java_class, Klass* klass) {
1483 assert(klass->is_klass() && klass->is_array_klass(), "should be array klass");
1484 java_class->release_metadata_field_put(_array_klass_offset, klass);
1485 }
1486
1487
1488 BasicType java_lang_Class::primitive_type(oop java_class) {
1489 assert(is_primitive(java_class), "just checking");
1490 Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset));
1491 BasicType type = T_VOID;
1492 if (ak != nullptr) {
1493 // Note: create_basic_type_mirror above initializes ak to a non-null value.
1494 type = ArrayKlass::cast(ak)->element_type();
1495 } else {
1496 assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
1497 }
1498 #ifdef ASSERT
1499 if (CDSConfig::is_dumping_heap()) {
1500 oop mirror = Universe::java_mirror(type);
1501 oop scratch_mirror = HeapShared::scratch_java_mirror(type);
1502 assert(java_class == mirror || java_class == scratch_mirror, "must be consistent");
1503 } else {
1523
1524 oop java_lang_Class::primitive_mirror(BasicType t) {
1525 oop mirror = Universe::java_mirror(t);
1526 assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
1527 assert(is_primitive(mirror), "must be primitive");
1528 return mirror;
1529 }
1530
1531 #define CLASS_FIELDS_DO(macro) \
1532 macro(_classRedefinedCount_offset, k, "classRedefinedCount", int_signature, false); \
1533 macro(_class_loader_offset, k, "classLoader", classloader_signature, false); \
1534 macro(_component_mirror_offset, k, "componentType", class_signature, false); \
1535 macro(_module_offset, k, "module", module_signature, false); \
1536 macro(_name_offset, k, "name", string_signature, false); \
1537 macro(_classData_offset, k, "classData", object_signature, false); \
1538 macro(_reflectionData_offset, k, "reflectionData", java_lang_ref_SoftReference_signature, false); \
1539 macro(_signers_offset, k, "signers", object_array_signature, false); \
1540 macro(_modifiers_offset, k, vmSymbols::modifiers_name(), char_signature, false); \
1541 macro(_raw_access_flags_offset, k, "classFileAccessFlags", char_signature, false); \
1542 macro(_protection_domain_offset, k, "protectionDomain", java_security_ProtectionDomain_signature, false); \
1543 macro(_is_primitive_offset, k, "primitive", bool_signature, false);
1544
1545 void java_lang_Class::compute_offsets() {
1546 if (_offsets_computed) {
1547 return;
1548 }
1549
1550 _offsets_computed = true;
1551
1552 InstanceKlass* k = vmClasses::Class_klass();
1553 CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1554 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1555 }
1556
1557 #if INCLUDE_CDS
1558 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1559 f->do_bool(&_offsets_computed);
1560
1561 CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1562
1563 CLASS_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
2825
2826 // the format of the stacktrace will be:
2827 // - 1 or more fillInStackTrace frames for the exception class (skipped)
2828 // - 0 or more <init> methods for the exception class (skipped)
2829 // - rest of the stack
2830
2831 if (!skip_fillInStackTrace_check) {
2832 if (method->name() == vmSymbols::fillInStackTrace_name() &&
2833 throwable->is_a(method->method_holder())) {
2834 continue;
2835 }
2836 else {
2837 skip_fillInStackTrace_check = true; // gone past them all
2838 }
2839 }
2840 if (!skip_throwableInit_check) {
2841 assert(skip_fillInStackTrace_check, "logic error in backtrace filtering");
2842
2843 // skip <init> methods of the exception class and superclasses
2844 // This is similar to classic VM.
2845 if (method->name() == vmSymbols::object_initializer_name() &&
2846 throwable->is_a(method->method_holder())) {
2847 continue;
2848 } else {
2849 // there are none or we've seen them all - either way stop checking
2850 skip_throwableInit_check = true;
2851 }
2852 }
2853 if (method->is_hidden() || method->is_continuation_enter_intrinsic()) {
2854 if (skip_hidden) {
2855 if (total_count == 0) {
2856 // The top frame will be hidden from the stack trace.
2857 bt.set_has_hidden_top_frame();
2858 }
2859 continue;
2860 }
2861 }
2862
2863 bt.push(method, bci, CHECK);
2864 total_count++;
2865 }
3184 int java_lang_ClassFrameInfo::_classOrMemberName_offset;
3185 int java_lang_ClassFrameInfo::_flags_offset;
3186
3187 #define CLASSFRAMEINFO_FIELDS_DO(macro) \
3188 macro(_classOrMemberName_offset, k, "classOrMemberName", object_signature, false); \
3189 macro(_flags_offset, k, vmSymbols::flags_name(), int_signature, false)
3190
3191 void java_lang_ClassFrameInfo::compute_offsets() {
3192 InstanceKlass* k = vmClasses::ClassFrameInfo_klass();
3193 CLASSFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3194 }
3195
3196 #if INCLUDE_CDS
3197 void java_lang_ClassFrameInfo::serialize_offsets(SerializeClosure* f) {
3198 CLASSFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3199 }
3200 #endif
3201
3202 static int get_flags(const methodHandle& m) {
3203 int flags = m->access_flags().as_method_flags();
3204 if (m->is_object_initializer()) {
3205 flags |= java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR;
3206 } else {
3207 // Note: Static initializers can be here. Record them as plain methods.
3208 flags |= java_lang_invoke_MemberName::MN_IS_METHOD;
3209 }
3210 if (m->caller_sensitive()) {
3211 flags |= java_lang_invoke_MemberName::MN_CALLER_SENSITIVE;
3212 }
3213 if (m->is_hidden()) {
3214 flags |= java_lang_invoke_MemberName::MN_HIDDEN_MEMBER;
3215 }
3216 assert((flags & 0xFF000000) == 0, "unexpected flags");
3217 return flags;
3218 }
3219
3220 oop java_lang_ClassFrameInfo::classOrMemberName(oop obj) {
3221 return obj->obj_field(_classOrMemberName_offset);
3222 }
3223
3224 int java_lang_ClassFrameInfo::flags(oop obj) {
3225 return obj->int_field(_flags_offset);
3576 constructor->int_field_put(_modifiers_offset, value);
3577 }
3578
3579 void java_lang_reflect_Constructor::set_signature(oop constructor, oop value) {
3580 constructor->obj_field_put(_signature_offset, value);
3581 }
3582
3583 void java_lang_reflect_Constructor::set_annotations(oop constructor, oop value) {
3584 constructor->obj_field_put(_annotations_offset, value);
3585 }
3586
3587 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
3588 method->obj_field_put(_parameter_annotations_offset, value);
3589 }
3590
3591 int java_lang_reflect_Field::_clazz_offset;
3592 int java_lang_reflect_Field::_name_offset;
3593 int java_lang_reflect_Field::_type_offset;
3594 int java_lang_reflect_Field::_slot_offset;
3595 int java_lang_reflect_Field::_modifiers_offset;
3596 int java_lang_reflect_Field::_trusted_final_offset;
3597 int java_lang_reflect_Field::_signature_offset;
3598 int java_lang_reflect_Field::_annotations_offset;
3599
3600 #define FIELD_FIELDS_DO(macro) \
3601 macro(_clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
3602 macro(_name_offset, k, vmSymbols::name_name(), string_signature, false); \
3603 macro(_type_offset, k, vmSymbols::type_name(), class_signature, false); \
3604 macro(_slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
3605 macro(_modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
3606 macro(_trusted_final_offset, k, vmSymbols::trusted_final_name(), bool_signature, false); \
3607 macro(_signature_offset, k, vmSymbols::signature_name(), string_signature, false); \
3608 macro(_annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature, false);
3609
3610 void java_lang_reflect_Field::compute_offsets() {
3611 InstanceKlass* k = vmClasses::reflect_Field_klass();
3612 FIELD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3613 }
3614
3615 #if INCLUDE_CDS
3616 void java_lang_reflect_Field::serialize_offsets(SerializeClosure* f) {
3617 FIELD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3618 }
3619 #endif
3620
3621 Handle java_lang_reflect_Field::create(TRAPS) {
3622 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3623 Symbol* name = vmSymbols::java_lang_reflect_Field();
3624 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
3625 InstanceKlass* ik = InstanceKlass::cast(k);
3626 // Ensure it is initialized
3651 void java_lang_reflect_Field::set_type(oop field, oop value) {
3652 field->obj_field_put(_type_offset, value);
3653 }
3654
3655 int java_lang_reflect_Field::slot(oop reflect) {
3656 return reflect->int_field(_slot_offset);
3657 }
3658
3659 void java_lang_reflect_Field::set_slot(oop reflect, int value) {
3660 reflect->int_field_put(_slot_offset, value);
3661 }
3662
3663 int java_lang_reflect_Field::modifiers(oop field) {
3664 return field->int_field(_modifiers_offset);
3665 }
3666
3667 void java_lang_reflect_Field::set_modifiers(oop field, int value) {
3668 field->int_field_put(_modifiers_offset, value);
3669 }
3670
3671 void java_lang_reflect_Field::set_trusted_final(oop field) {
3672 field->bool_field_put(_trusted_final_offset, true);
3673 }
3674
3675 void java_lang_reflect_Field::set_signature(oop field, oop value) {
3676 field->obj_field_put(_signature_offset, value);
3677 }
3678
3679 void java_lang_reflect_Field::set_annotations(oop field, oop value) {
3680 field->obj_field_put(_annotations_offset, value);
3681 }
3682
3683 oop java_lang_reflect_RecordComponent::create(InstanceKlass* holder, RecordComponent* component, TRAPS) {
3684 // Allocate java.lang.reflect.RecordComponent instance
3685 HandleMark hm(THREAD);
3686 InstanceKlass* ik = vmClasses::RecordComponent_klass();
3687 assert(ik != nullptr, "must be loaded");
3688 ik->initialize(CHECK_NULL);
3689
3690 Handle element = ik->allocate_instance_handle(CHECK_NULL);
3691
3692 Handle decl_class(THREAD, holder->java_mirror());
3952 }
3953 #endif
3954
3955 bool java_lang_ref_Reference::is_referent_field(oop obj, ptrdiff_t offset) {
3956 assert(obj != nullptr, "sanity");
3957 if (offset != _referent_offset) {
3958 return false;
3959 }
3960
3961 Klass* k = obj->klass();
3962 if (!k->is_instance_klass()) {
3963 return false;
3964 }
3965
3966 InstanceKlass* ik = InstanceKlass::cast(obj->klass());
3967 bool is_reference = ik->reference_type() != REF_NONE;
3968 assert(!is_reference || ik->is_subclass_of(vmClasses::Reference_klass()), "sanity");
3969 return is_reference;
3970 }
3971
3972 int java_lang_boxing_object::_value_offset;
3973 int java_lang_boxing_object::_long_value_offset;
3974
3975 #define BOXING_FIELDS_DO(macro) \
3976 macro(_value_offset, integerKlass, "value", int_signature, false); \
3977 macro(_long_value_offset, longKlass, "value", long_signature, false);
3978
3979 void java_lang_boxing_object::compute_offsets() {
3980 InstanceKlass* integerKlass = vmClasses::Integer_klass();
3981 InstanceKlass* longKlass = vmClasses::Long_klass();
3982 BOXING_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3983 }
3984
3985 #if INCLUDE_CDS
3986 void java_lang_boxing_object::serialize_offsets(SerializeClosure* f) {
3987 BOXING_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3988 }
3989 #endif
3990
3991 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
3992 Klass* k = vmClasses::box_klass(type);
3993 if (k == nullptr) return nullptr;
3994 InstanceKlass* ik = InstanceKlass::cast(k);
3995 if (!ik->is_initialized()) {
3996 ik->initialize(CHECK_NULL);
3997 }
3998 return ik->allocate_instance(THREAD);
3999 }
4000
4001
4002 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
4003 oop box = initialize_and_allocate(type, CHECK_NULL);
4004 if (box == nullptr) return nullptr;
4005 switch (type) {
4006 case T_BOOLEAN:
4007 box->bool_field_put(_value_offset, value->z);
4008 break;
4009 case T_CHAR:
4010 box->char_field_put(_value_offset, value->c);
4011 break;
4012 case T_FLOAT:
4013 box->float_field_put(_value_offset, value->f);
4014 break;
4015 case T_DOUBLE:
4016 box->double_field_put(_long_value_offset, value->d);
4017 break;
4018 case T_BYTE:
4019 box->byte_field_put(_value_offset, value->b);
4020 break;
4021 case T_SHORT:
4022 box->short_field_put(_value_offset, value->s);
4023 break;
4024 case T_INT:
4025 box->int_field_put(_value_offset, value->i);
4026 break;
4027 case T_LONG:
4028 box->long_field_put(_long_value_offset, value->j);
4029 break;
4030 default:
4031 return nullptr;
4032 }
4033 return box;
4034 }
4035
4036
4037 BasicType java_lang_boxing_object::basic_type(oop box) {
4038 if (box == nullptr) return T_ILLEGAL;
4039 BasicType type = vmClasses::box_klass_type(box->klass());
4040 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt
4041 return T_ILLEGAL;
4042 return type;
4043 }
4044
4045
4046 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
4047 BasicType type = vmClasses::box_klass_type(box->klass());
4048 switch (type) {
4049 case T_BOOLEAN:
4050 value->z = box->bool_field(_value_offset);
4051 break;
4052 case T_CHAR:
4053 value->c = box->char_field(_value_offset);
4054 break;
4055 case T_FLOAT:
4056 value->f = box->float_field(_value_offset);
4057 break;
4058 case T_DOUBLE:
4059 value->d = box->double_field(_long_value_offset);
4060 break;
4061 case T_BYTE:
4062 value->b = box->byte_field(_value_offset);
4063 break;
4064 case T_SHORT:
4065 value->s = box->short_field(_value_offset);
4066 break;
4067 case T_INT:
4068 value->i = box->int_field(_value_offset);
4069 break;
4070 case T_LONG:
4071 value->j = box->long_field(_long_value_offset);
4072 break;
4073 default:
4074 return T_ILLEGAL;
4075 } // end switch
4076 return type;
4077 }
4078
4079
4080 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
4081 BasicType type = vmClasses::box_klass_type(box->klass());
4082 switch (type) {
4083 case T_BOOLEAN:
4084 box->bool_field_put(_value_offset, value->z);
4085 break;
4086 case T_CHAR:
4087 box->char_field_put(_value_offset, value->c);
4088 break;
4089 case T_FLOAT:
4090 box->float_field_put(_value_offset, value->f);
4091 break;
4092 case T_DOUBLE:
4093 box->double_field_put(_long_value_offset, value->d);
4094 break;
4095 case T_BYTE:
4096 box->byte_field_put(_value_offset, value->b);
4097 break;
4098 case T_SHORT:
4099 box->short_field_put(_value_offset, value->s);
4100 break;
4101 case T_INT:
4102 box->int_field_put(_value_offset, value->i);
4103 break;
4104 case T_LONG:
4105 box->long_field_put(_long_value_offset, value->j);
4106 break;
4107 default:
4108 return T_ILLEGAL;
4109 } // end switch
4110 return type;
4111 }
4112
4113
4114 void java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream* st) {
4115 switch (type) {
4116 case T_BOOLEAN: st->print("%s", value->z ? "true" : "false"); break;
4117 case T_CHAR: st->print("%d", value->c); break;
4118 case T_BYTE: st->print("%d", value->b); break;
4119 case T_SHORT: st->print("%d", value->s); break;
4120 case T_INT: st->print("%d", value->i); break;
4121 case T_LONG: st->print(JLONG_FORMAT, value->j); break;
4122 case T_FLOAT: st->print("%f", value->f); break;
4123 case T_DOUBLE: st->print("%lf", value->d); break;
4124 default: st->print("type %d?", type); break;
4125 }
4405
4406 #define CallConv_FIELDS_DO(macro) \
4407 macro(_argRegs_offset, k, "argRegs", jdk_internal_foreign_abi_VMStorage_array_signature, false); \
4408 macro(_retRegs_offset, k, "retRegs", jdk_internal_foreign_abi_VMStorage_array_signature, false); \
4409
4410 bool jdk_internal_foreign_abi_CallConv::is_instance(oop obj) {
4411 return obj != nullptr && is_subclass(obj->klass());
4412 }
4413
4414 void jdk_internal_foreign_abi_CallConv::compute_offsets() {
4415 InstanceKlass* k = vmClasses::CallConv_klass();
4416 CallConv_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4417 }
4418
4419 #if INCLUDE_CDS
4420 void jdk_internal_foreign_abi_CallConv::serialize_offsets(SerializeClosure* f) {
4421 CallConv_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4422 }
4423 #endif
4424
4425 objArrayOop jdk_internal_foreign_abi_CallConv::argRegs(oop entry) {
4426 return oop_cast<objArrayOop>(entry->obj_field(_argRegs_offset));
4427 }
4428
4429 objArrayOop jdk_internal_foreign_abi_CallConv::retRegs(oop entry) {
4430 return oop_cast<objArrayOop>(entry->obj_field(_retRegs_offset));
4431 }
4432
4433 oop java_lang_invoke_MethodHandle::type(oop mh) {
4434 return mh->obj_field(_type_offset);
4435 }
4436
4437 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
4438 mh->obj_field_put(_type_offset, mtype);
4439 }
4440
4441 oop java_lang_invoke_MethodHandle::form(oop mh) {
4442 assert(_form_offset != 0, "");
4443 return mh->obj_field(_form_offset);
4444 }
4445
4446 void java_lang_invoke_MethodHandle::set_form(oop mh, oop lform) {
4447 assert(_form_offset != 0, "");
4448 mh->obj_field_put(_form_offset, lform);
4449 }
4450
4473 oop java_lang_invoke_MemberName::type(oop mname) {
4474 assert(is_instance(mname), "wrong type");
4475 return mname->obj_field(_type_offset);
4476 }
4477
4478 void java_lang_invoke_MemberName::set_type(oop mname, oop type) {
4479 assert(is_instance(mname), "wrong type");
4480 mname->obj_field_put(_type_offset, type);
4481 }
4482
4483 int java_lang_invoke_MemberName::flags(oop mname) {
4484 assert(is_instance(mname), "wrong type");
4485 return mname->int_field(_flags_offset);
4486 }
4487
4488 void java_lang_invoke_MemberName::set_flags(oop mname, int flags) {
4489 assert(is_instance(mname), "wrong type");
4490 mname->int_field_put(_flags_offset, flags);
4491 }
4492
4493
4494 // Return vmtarget from ResolvedMethodName method field through indirection
4495 Method* java_lang_invoke_MemberName::vmtarget(oop mname) {
4496 assert(is_instance(mname), "wrong type");
4497 oop method = mname->obj_field(_method_offset);
4498 return method == nullptr ? nullptr : java_lang_invoke_ResolvedMethodName::vmtarget(method);
4499 }
4500
4501 bool java_lang_invoke_MemberName::is_method(oop mname) {
4502 assert(is_instance(mname), "must be MemberName");
4503 return (flags(mname) & (MN_IS_METHOD | MN_IS_CONSTRUCTOR)) > 0;
4504 }
4505
4506 void java_lang_invoke_MemberName::set_method(oop mname, oop resolved_method) {
4507 assert(is_instance(mname), "wrong type");
4508 mname->obj_field_put(_method_offset, resolved_method);
4509 }
4510
4511 intptr_t java_lang_invoke_MemberName::vmindex(oop mname) {
4512 assert(is_instance(mname), "wrong type");
4513 return (intptr_t) mname->address_field(_vmindex_offset);
4514 }
4515
4516 void java_lang_invoke_MemberName::set_vmindex(oop mname, intptr_t index) {
4517 assert(is_instance(mname), "wrong type");
4518 mname->address_field_put(_vmindex_offset, (address) index);
4519 }
4520
4521
4522 Method* java_lang_invoke_ResolvedMethodName::vmtarget(oop resolved_method) {
4523 assert(is_instance(resolved_method), "wrong type");
5476 if (!ik->find_local_field(f_name, f_sig, &fd)) {
5477 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
5478 return false;
5479 }
5480 if (fd.is_static()) {
5481 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);
5482 return false;
5483 }
5484 if (fd.offset() == deserialized_offset ) {
5485 return true;
5486 } else {
5487 tty->print_cr("Offset of nonstatic field %s.%s is deserialized as %d but should really be %d.",
5488 klass_name, field_name, deserialized_offset, fd.offset());
5489 return false;
5490 }
5491 }
5492
5493 void JavaClasses::check_offsets() {
5494 bool valid = true;
5495
5496 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
5497 valid &= check_offset(klass_name, cpp_klass_name :: _##field_name ## _offset, #field_name, field_sig)
5498
5499 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
5500 valid &= check_offset(klass_name, cpp_klass_name :: _##long_ ## field_name ## _offset, #field_name, field_sig)
5501
5502 // Boxed primitive objects (java_lang_boxing_object)
5503
5504 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
5505 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
5506 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
5507 CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D");
5508 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B");
5509 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S");
5510 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I");
5511 CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J");
5512
5513 if (!valid) vm_exit_during_initialization("Field offset verification failed");
5514 }
5515
5516 #endif // PRODUCT
5517
5518 int InjectedField::compute_offset() {
5519 InstanceKlass* ik = klass();
5520 for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
5521 if (!may_be_java && !fs.field_flags().is_injected()) {
5522 // Only look at injected fields
5523 continue;
5524 }
5525 if (fs.name() == name() && fs.signature() == signature()) {
5526 return fs.offset();
5527 }
5528 }
5529 ResourceMark rm;
5530 tty->print_cr("Invalid layout of %s at %s/%s%s", ik->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : "");
5531 #ifndef PRODUCT
|
35 #include "classfile/moduleEntry.hpp"
36 #include "classfile/stringTable.hpp"
37 #include "classfile/symbolTable.hpp"
38 #include "classfile/systemDictionary.hpp"
39 #include "classfile/vmClasses.hpp"
40 #include "classfile/vmSymbols.hpp"
41 #include "code/debugInfo.hpp"
42 #include "code/dependencyContext.hpp"
43 #include "code/pcDesc.hpp"
44 #include "gc/shared/collectedHeap.inline.hpp"
45 #include "interpreter/interpreter.hpp"
46 #include "interpreter/linkResolver.hpp"
47 #include "jvm.h"
48 #include "logging/log.hpp"
49 #include "logging/logStream.hpp"
50 #include "memory/oopFactory.hpp"
51 #include "memory/resourceArea.hpp"
52 #include "memory/universe.hpp"
53 #include "oops/fieldInfo.hpp"
54 #include "oops/fieldStreams.inline.hpp"
55 #include "oops/flatArrayKlass.hpp"
56 #include "oops/inlineKlass.inline.hpp"
57 #include "oops/instanceKlass.inline.hpp"
58 #include "oops/instanceMirrorKlass.inline.hpp"
59 #include "oops/klass.inline.hpp"
60 #include "oops/method.inline.hpp"
61 #include "oops/objArrayKlass.hpp"
62 #include "oops/objArrayOop.inline.hpp"
63 #include "oops/oop.inline.hpp"
64 #include "oops/oopCast.inline.hpp"
65 #include "oops/recordComponent.hpp"
66 #include "oops/symbol.hpp"
67 #include "oops/typeArrayOop.inline.hpp"
68 #include "prims/jvmtiExport.hpp"
69 #include "prims/methodHandles.hpp"
70 #include "prims/resolvedMethodTable.hpp"
71 #include "runtime/continuationEntry.inline.hpp"
72 #include "runtime/continuationJavaClasses.inline.hpp"
73 #include "runtime/fieldDescriptor.inline.hpp"
74 #include "runtime/frame.inline.hpp"
75 #include "runtime/handles.inline.hpp"
76 #include "runtime/handshake.hpp"
77 #include "runtime/init.hpp"
78 #include "runtime/interfaceSupport.inline.hpp"
853
854 // java_lang_Class
855
856 int java_lang_Class::_klass_offset;
857 int java_lang_Class::_array_klass_offset;
858 int java_lang_Class::_oop_size_offset;
859 int java_lang_Class::_static_oop_field_count_offset;
860 int java_lang_Class::_class_loader_offset;
861 int java_lang_Class::_module_offset;
862 int java_lang_Class::_protection_domain_offset;
863 int java_lang_Class::_component_mirror_offset;
864 int java_lang_Class::_init_lock_offset;
865 int java_lang_Class::_signers_offset;
866 int java_lang_Class::_name_offset;
867 int java_lang_Class::_source_file_offset;
868 int java_lang_Class::_classData_offset;
869 int java_lang_Class::_classRedefinedCount_offset;
870 int java_lang_Class::_reflectionData_offset;
871 int java_lang_Class::_modifiers_offset;
872 int java_lang_Class::_is_primitive_offset;
873 int java_lang_Class::_is_identity_offset;
874 int java_lang_Class::_raw_access_flags_offset;
875
876 bool java_lang_Class::_offsets_computed = false;
877 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = nullptr;
878 GrowableArray<Klass*>* java_lang_Class::_fixup_module_field_list = nullptr;
879
880 #ifdef ASSERT
881 inline static void assert_valid_static_string_field(fieldDescriptor* fd) {
882 assert(fd->has_initial_value(), "caller should have checked this");
883 assert(fd->field_type() == T_OBJECT, "caller should have checked this");
884 assert(fd->signature() == vmSymbols::string_signature(), "just checking");
885 }
886 #endif
887
888 static void initialize_static_string_field(fieldDescriptor* fd, Handle mirror, TRAPS) {
889 DEBUG_ONLY(assert_valid_static_string_field(fd);)
890 oop string = fd->string_initial_value(CHECK);
891 mirror()->obj_field_put(fd->offset(), string);
892 }
893
1077 // With AOT-linked classes, java.base module is defined before any class
1078 // is loaded, so there's no need for fixup_module_field_list().
1079 GrowableArray<Klass*>* module_list =
1080 new (mtModule) GrowableArray<Klass*>(500, mtModule);
1081 set_fixup_module_field_list(module_list);
1082 }
1083 }
1084
1085 void java_lang_Class::allocate_mirror(Klass* k, bool is_scratch, Handle protection_domain, Handle classData,
1086 Handle& mirror, Handle& comp_mirror, TRAPS) {
1087 // Allocate mirror (java.lang.Class instance)
1088 oop mirror_oop = InstanceMirrorKlass::cast(vmClasses::Class_klass())->allocate_instance(k, CHECK);
1089 mirror = Handle(THREAD, mirror_oop);
1090
1091 // Setup indirection from mirror->klass
1092 set_klass(mirror(), k);
1093
1094 // Set the modifiers flag.
1095 u2 computed_modifiers = k->compute_modifier_flags();
1096 set_modifiers(mirror(), computed_modifiers);
1097 set_is_identity(mirror(), k->is_array_klass() || k->is_identity_class());
1098
1099 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
1100 assert(oop_size(mirror()) == mk->instance_size(k), "should have been set");
1101
1102 set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
1103
1104 // It might also have a component mirror. This mirror must already exist.
1105 if (k->is_array_klass()) {
1106 // The Java code for array classes gets the access flags from the element type.
1107 set_raw_access_flags(mirror(), 0);
1108 if (k->is_flatArray_klass()) {
1109 Klass* element_klass = (Klass*) FlatArrayKlass::cast(k)->element_klass();
1110 assert(element_klass->is_inline_klass(), "Must be inline type component");
1111 if (is_scratch) {
1112 comp_mirror = Handle(THREAD, HeapShared::scratch_java_mirror(element_klass));
1113 } else {
1114 comp_mirror = Handle(THREAD, element_klass->java_mirror());
1115 }
1116 } else if (k->is_typeArray_klass()) {
1117 BasicType type = TypeArrayKlass::cast(k)->element_type();
1118 if (is_scratch) {
1119 comp_mirror = Handle(THREAD, HeapShared::scratch_java_mirror(type));
1120 } else {
1121 comp_mirror = Handle(THREAD, Universe::java_mirror(type));
1122 }
1123 } else {
1124 assert(k->is_objArray_klass(), "Must be");
1125 assert(!k->is_refArray_klass() || !k->is_flatArray_klass(), "Must not have mirror");
1126 Klass* element_klass = ObjArrayKlass::cast(k)->element_klass();
1127 assert(element_klass != nullptr, "Must have an element klass");
1128 oop comp_oop = element_klass->java_mirror();
1129 if (is_scratch) {
1130 comp_mirror = Handle(THREAD, HeapShared::scratch_java_mirror(element_klass));
1131 } else {
1132 comp_mirror = Handle(THREAD, comp_oop);
1133 }
1134 }
1135 assert(comp_mirror() != nullptr, "must have a mirror");
1136
1137 // Two-way link between the array klass and its component mirror:
1138 // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
1139 set_component_mirror(mirror(), comp_mirror());
1140 // See below for ordering dependencies between field array_klass in component mirror
1141 // and java_mirror in this klass.
1142 } else {
1143 assert(k->is_instance_klass(), "Must be");
1144 // Set the raw access_flags, this is used by reflection instead of modifier flags.
1145 set_raw_access_flags(mirror(), InstanceKlass::cast(k)->access_flags().as_unsigned_short());
1146 initialize_mirror_fields(InstanceKlass::cast(k), mirror, protection_domain, classData, THREAD);
1147 if (HAS_PENDING_EXCEPTION) {
1148 // If any of the fields throws an exception like OOM remove the klass field
1149 // from the mirror so GC doesn't follow it after the klass has been deallocated.
1150 // This mirror looks like a primitive type, which logically it is because it
1151 // it represents no class.
1152 set_klass(mirror(), nullptr);
1153 return;
1154 }
1155 }
1156 }
1157
1158 void java_lang_Class::create_mirror(Klass* k, Handle class_loader,
1159 Handle module, Handle protection_domain,
1160 Handle classData, TRAPS) {
1161 assert(k != nullptr, "Use create_basic_type_mirror for primitive types");
1162 assert(k->java_mirror() == nullptr, "should only assign mirror once");
1163 // Class_klass has to be loaded because it is used to allocate
1164 // the mirror.
1165 if (vmClasses::Class_klass_is_loaded()) {
1166
1167 if (k->is_refined_objArray_klass()) {
1168 Klass* super_klass = k->super();
1169 assert(super_klass != nullptr, "Must be");
1170 Handle mirror(THREAD, super_klass->java_mirror());
1171 k->set_java_mirror(mirror);
1172 return;
1173 }
1174
1175 Handle mirror;
1176 Handle comp_mirror;
1177
1178 allocate_mirror(k, /*is_scratch=*/false, protection_domain, classData, mirror, comp_mirror, CHECK);
1179
1180 // set the classLoader field in the java_lang_Class instance
1181 assert(class_loader() == k->class_loader(), "should be same");
1182 set_class_loader(mirror(), class_loader());
1183
1184 // Setup indirection from klass->mirror
1185 // after any exceptions can happen during allocations.
1186 k->set_java_mirror(mirror);
1187
1188 // Set the module field in the java_lang_Class instance. This must be done
1189 // after the mirror is set.
1190 set_mirror_module_field(THREAD, k, mirror, module);
1191
1192 if (comp_mirror() != nullptr) {
1193 // Set after k->java_mirror() is published, because compiled code running
1194 // concurrently doesn't expect a k to have a null java_mirror.
1195 release_set_array_klass(comp_mirror(), k);
1196 }
1197
1198 if (CDSConfig::is_dumping_heap()) {
1199 create_scratch_mirror(k, CHECK);
1200 }
1201 } else {
1202 assert(!CDSConfig::is_using_aot_linked_classes(), "should not come here");
1203 assert(fixup_mirror_list() != nullptr, "fixup_mirror_list not initialized");
1204 fixup_mirror_list()->push(k);
1205 }
1206 }
1207
1208 #if INCLUDE_CDS_JAVA_HEAP
1209 // The "scratch mirror" stores the states of the mirror object that can be
1210 // decided at dump time (such as the initial values of the static fields, the
1211 // component mirror, etc). At runtime, more information is added to it by
1212 // java_lang_Class::restore_archived_mirror().
1213 //
1214 // Essentially, /*dumptime*/create_scratch_mirror() + /*runtime*/restore_archived_mirror()
1215 // produces the same result as /*runtime*/create_mirror().
1216 //
1217 // Note: we archive the "scratch mirror" instead of k->java_mirror(), because the
1218 // latter may contain dumptime-specific information that cannot be archived
1219 // (e.g., ClassLoaderData*, or static fields that are modified by Java code execution).
1220 void java_lang_Class::create_scratch_mirror(Klass* k, TRAPS) {
1221 if ((k->class_loader() != nullptr &&
1222 k->class_loader() != SystemDictionary::java_platform_loader() &&
1223 k->class_loader() != SystemDictionary::java_system_loader())) {
1224 // We only archive the mirrors of classes loaded by the built-in loaders
1225 return;
1226 }
1227
1228 Handle protection_domain, classData; // set to null. Will be reinitialized at runtime
1229 Handle mirror;
1230 Handle comp_mirror;
1231 allocate_mirror(k, /*is_scratch=*/true, protection_domain, classData, mirror, comp_mirror, CHECK);
1232
1233 if (comp_mirror() != nullptr) {
1234 release_set_array_klass(comp_mirror(), k);
1235 }
1236
1237 HeapShared::set_scratch_java_mirror(k, mirror());
1238 }
1239
1240 // Returns true if the mirror is updated, false if no archived mirror
1241 // data is present. After the archived mirror object is restored, the
1242 // shared klass' _has_raw_archived_mirror flag is cleared.
1243 bool java_lang_Class::restore_archived_mirror(Klass *k,
1244 Handle class_loader, Handle module,
1245 Handle protection_domain, TRAPS) {
1246 // Postpone restoring archived mirror until java.lang.Class is loaded. Please
1247 // see more details in vmClasses::resolve_all().
1248 if (!vmClasses::Class_klass_is_loaded() && !CDSConfig::is_using_aot_linked_classes()) {
1249 assert(fixup_mirror_list() != nullptr, "fixup_mirror_list not initialized");
1250 fixup_mirror_list()->push(k);
1251 return true;
1252 }
1253
1254 oop m = k->archived_java_mirror();
1255 assert(m != nullptr, "must have stored non-null archived mirror");
1256
1257 // Sanity: clear it now to prevent re-initialization if any of the following fails
1258 k->clear_archived_mirror_index();
1259
1260 // mirror is archived, restore
1261 log_debug(aot, mirror)("Archived mirror is: " PTR_FORMAT, p2i(m));
1262 Handle mirror(THREAD, m);
1263
1264 if (!k->is_array_klass()) {
1265 assert(as_Klass(m) == k, "must be");
1266 // - local static final fields with initial values were initialized at dump time
1267 assert(init_lock(mirror()) != nullptr, "allocated during AOT assembly");
1268
1269 if (protection_domain.not_null()) {
1270 set_protection_domain(mirror(), protection_domain());
1271 }
1272 } else if (k->is_objArray_klass()) {
1273 ObjArrayKlass* objarray_k = (ObjArrayKlass*)as_Klass(m);
1274 // Mirror should be restored for an ObjArrayKlass or one of its refined array klasses
1275 assert(objarray_k == k || objarray_k->find_refined_array_klass((ObjArrayKlass*)k), "must be");
1276 }
1277
1278 assert(class_loader() == k->class_loader(), "should be same");
1279 if (class_loader.not_null()) {
1280 set_class_loader(mirror(), class_loader());
1281 }
1282
1283 k->set_java_mirror(mirror);
1284
1285 set_mirror_module_field(THREAD, k, mirror, module);
1286
1287 if (log_is_enabled(Trace, aot, heap, mirror)) {
1288 ResourceMark rm(THREAD);
1289 log_trace(aot, heap, mirror)(
1290 "Restored %s archived mirror " PTR_FORMAT, k->external_name(), p2i(mirror()));
1291 }
1292
1293 if (CDSConfig::is_dumping_heap() && (!k->is_refined_objArray_klass())) {
1294 create_scratch_mirror(k, CHECK_(false));
1295 }
1296
1297 return true;
1298 }
1299 #endif // INCLUDE_CDS_JAVA_HEAP
1300
1301 void java_lang_Class::fixup_module_field(Klass* k, Handle module) {
1302 assert(_module_offset != 0, "must have been computed already");
1303 set_module(k->java_mirror(), module());
1304 }
1305
1306 void java_lang_Class::set_oop_size(HeapWord* java_class, size_t size) {
1307 assert(_oop_size_offset != 0, "must be set");
1308 assert(size > 0, "Oop size must be greater than zero, not %zu", size);
1309 assert(size <= INT_MAX, "Lossy conversion: %zu", size);
1310 *(int*)(((char*)java_class) + _oop_size_offset) = (int)size;
1311 }
1312
1313 int java_lang_Class::static_oop_field_count(oop java_class) {
1392 java_class->obj_field_put(_name_offset, o);
1393 }
1394 return o;
1395 }
1396
1397 oop java_lang_Class::source_file(oop java_class) {
1398 assert(_source_file_offset != 0, "must be set");
1399 return java_class->obj_field(_source_file_offset);
1400 }
1401
1402 void java_lang_Class::set_source_file(oop java_class, oop source_file) {
1403 assert(_source_file_offset != 0, "must be set");
1404 java_class->obj_field_put(_source_file_offset, source_file);
1405 }
1406
1407 void java_lang_Class::set_is_primitive(oop java_class) {
1408 assert(_is_primitive_offset != 0, "must be set");
1409 java_class->bool_field_put(_is_primitive_offset, true);
1410 }
1411
1412 void java_lang_Class::set_is_identity(oop java_class, bool value) {
1413 assert(_is_identity_offset != 0, "must be set");
1414 java_class->bool_field_put(_is_identity_offset, value);
1415 }
1416
1417 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
1418 // Mirrors for basic types have a null klass field, which makes them special.
1419 oop java_class = InstanceMirrorKlass::cast(vmClasses::Class_klass())->allocate_instance(nullptr, CHECK_NULL);
1420 if (type != T_VOID) {
1421 Klass* aklass = Universe::typeArrayKlass(type);
1422 assert(aklass != nullptr, "correct bootstrap");
1423 release_set_array_klass(java_class, aklass);
1424 }
1425 #ifdef ASSERT
1426 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(vmClasses::Class_klass());
1427 assert(static_oop_field_count(java_class) == 0, "should have been zeroed by allocation");
1428 #endif
1429 set_modifiers(java_class, JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
1430 set_raw_access_flags(java_class, JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
1431
1432 set_is_primitive(java_class);
1433 return java_class;
1434 }
1435
1437 assert(is_instance(java_class), "must be a Class object");
1438 java_class->metadata_field_put(_klass_offset, klass);
1439 }
1440
1441
1442 void java_lang_Class::print_signature(oop java_class, outputStream* st) {
1443 assert(is_instance(java_class), "must be a Class object");
1444 Symbol* name = nullptr;
1445 bool is_instance = false;
1446 if (is_primitive(java_class)) {
1447 name = vmSymbols::type_signature(primitive_type(java_class));
1448 } else {
1449 Klass* k = as_Klass(java_class);
1450 is_instance = k->is_instance_klass();
1451 name = k->name();
1452 }
1453 if (name == nullptr) {
1454 st->print("<null>");
1455 return;
1456 }
1457 if (is_instance) {
1458 st->print("L");
1459 }
1460 st->write((char*) name->base(), (int) name->utf8_length());
1461 if (is_instance) st->print(";");
1462 }
1463
1464 Symbol* java_lang_Class::as_signature(oop java_class, bool intern_if_not_found) {
1465 assert(is_instance(java_class), "must be a Class object");
1466 Symbol* name;
1467 if (is_primitive(java_class)) {
1468 name = vmSymbols::type_signature(primitive_type(java_class));
1469 // Because this can create a new symbol, the caller has to decrement
1470 // the refcount, so make adjustment here and below for symbols returned
1471 // that are not created or incremented due to a successful lookup.
1472 name->increment_refcount();
1473 } else {
1474 Klass* k = as_Klass(java_class);
1475 if (!k->is_instance_klass()) {
1476 name = k->name();
1477 name->increment_refcount();
1478 } else {
1479 ResourceMark rm;
1497 const char* name = nullptr;
1498 if (is_primitive(java_class)) {
1499 name = type2name(primitive_type(java_class));
1500 } else {
1501 name = as_Klass(java_class)->external_name();
1502 }
1503 if (name == nullptr) {
1504 name = "<null>";
1505 }
1506 return name;
1507 }
1508
1509 Klass* java_lang_Class::array_klass_acquire(oop java_class) {
1510 Klass* k = ((Klass*)java_class->metadata_field_acquire(_array_klass_offset));
1511 assert(k == nullptr || (k->is_klass() && k->is_array_klass()), "should be array klass");
1512 return k;
1513 }
1514
1515 void java_lang_Class::release_set_array_klass(oop java_class, Klass* klass) {
1516 assert(klass->is_klass() && klass->is_array_klass(), "should be array klass");
1517 assert(!klass->is_refined_objArray_klass(), "should not be ref or flat array klass");
1518 java_class->release_metadata_field_put(_array_klass_offset, klass);
1519 }
1520
1521
1522 BasicType java_lang_Class::primitive_type(oop java_class) {
1523 assert(is_primitive(java_class), "just checking");
1524 Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset));
1525 BasicType type = T_VOID;
1526 if (ak != nullptr) {
1527 // Note: create_basic_type_mirror above initializes ak to a non-null value.
1528 type = ArrayKlass::cast(ak)->element_type();
1529 } else {
1530 assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
1531 }
1532 #ifdef ASSERT
1533 if (CDSConfig::is_dumping_heap()) {
1534 oop mirror = Universe::java_mirror(type);
1535 oop scratch_mirror = HeapShared::scratch_java_mirror(type);
1536 assert(java_class == mirror || java_class == scratch_mirror, "must be consistent");
1537 } else {
1557
1558 oop java_lang_Class::primitive_mirror(BasicType t) {
1559 oop mirror = Universe::java_mirror(t);
1560 assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
1561 assert(is_primitive(mirror), "must be primitive");
1562 return mirror;
1563 }
1564
1565 #define CLASS_FIELDS_DO(macro) \
1566 macro(_classRedefinedCount_offset, k, "classRedefinedCount", int_signature, false); \
1567 macro(_class_loader_offset, k, "classLoader", classloader_signature, false); \
1568 macro(_component_mirror_offset, k, "componentType", class_signature, false); \
1569 macro(_module_offset, k, "module", module_signature, false); \
1570 macro(_name_offset, k, "name", string_signature, false); \
1571 macro(_classData_offset, k, "classData", object_signature, false); \
1572 macro(_reflectionData_offset, k, "reflectionData", java_lang_ref_SoftReference_signature, false); \
1573 macro(_signers_offset, k, "signers", object_array_signature, false); \
1574 macro(_modifiers_offset, k, vmSymbols::modifiers_name(), char_signature, false); \
1575 macro(_raw_access_flags_offset, k, "classFileAccessFlags", char_signature, false); \
1576 macro(_protection_domain_offset, k, "protectionDomain", java_security_ProtectionDomain_signature, false); \
1577 macro(_is_primitive_offset, k, "primitive", bool_signature, false); \
1578 macro(_is_identity_offset, k, "identity", bool_signature, false);
1579
1580 void java_lang_Class::compute_offsets() {
1581 if (_offsets_computed) {
1582 return;
1583 }
1584
1585 _offsets_computed = true;
1586
1587 InstanceKlass* k = vmClasses::Class_klass();
1588 CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1589 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1590 }
1591
1592 #if INCLUDE_CDS
1593 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1594 f->do_bool(&_offsets_computed);
1595
1596 CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1597
1598 CLASS_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
2860
2861 // the format of the stacktrace will be:
2862 // - 1 or more fillInStackTrace frames for the exception class (skipped)
2863 // - 0 or more <init> methods for the exception class (skipped)
2864 // - rest of the stack
2865
2866 if (!skip_fillInStackTrace_check) {
2867 if (method->name() == vmSymbols::fillInStackTrace_name() &&
2868 throwable->is_a(method->method_holder())) {
2869 continue;
2870 }
2871 else {
2872 skip_fillInStackTrace_check = true; // gone past them all
2873 }
2874 }
2875 if (!skip_throwableInit_check) {
2876 assert(skip_fillInStackTrace_check, "logic error in backtrace filtering");
2877
2878 // skip <init> methods of the exception class and superclasses
2879 // This is similar to classic VM.
2880 if (method->is_object_constructor() &&
2881 throwable->is_a(method->method_holder())) {
2882 continue;
2883 } else {
2884 // there are none or we've seen them all - either way stop checking
2885 skip_throwableInit_check = true;
2886 }
2887 }
2888 if (method->is_hidden() || method->is_continuation_enter_intrinsic()) {
2889 if (skip_hidden) {
2890 if (total_count == 0) {
2891 // The top frame will be hidden from the stack trace.
2892 bt.set_has_hidden_top_frame();
2893 }
2894 continue;
2895 }
2896 }
2897
2898 bt.push(method, bci, CHECK);
2899 total_count++;
2900 }
3219 int java_lang_ClassFrameInfo::_classOrMemberName_offset;
3220 int java_lang_ClassFrameInfo::_flags_offset;
3221
3222 #define CLASSFRAMEINFO_FIELDS_DO(macro) \
3223 macro(_classOrMemberName_offset, k, "classOrMemberName", object_signature, false); \
3224 macro(_flags_offset, k, vmSymbols::flags_name(), int_signature, false)
3225
3226 void java_lang_ClassFrameInfo::compute_offsets() {
3227 InstanceKlass* k = vmClasses::ClassFrameInfo_klass();
3228 CLASSFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3229 }
3230
3231 #if INCLUDE_CDS
3232 void java_lang_ClassFrameInfo::serialize_offsets(SerializeClosure* f) {
3233 CLASSFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3234 }
3235 #endif
3236
3237 static int get_flags(const methodHandle& m) {
3238 int flags = m->access_flags().as_method_flags();
3239 if (m->is_object_constructor()) {
3240 flags |= java_lang_invoke_MemberName::MN_IS_OBJECT_CONSTRUCTOR;
3241 } else {
3242 // Note: Static initializers can be here. Record them as plain methods.
3243 flags |= java_lang_invoke_MemberName::MN_IS_METHOD;
3244 }
3245 if (m->caller_sensitive()) {
3246 flags |= java_lang_invoke_MemberName::MN_CALLER_SENSITIVE;
3247 }
3248 if (m->is_hidden()) {
3249 flags |= java_lang_invoke_MemberName::MN_HIDDEN_MEMBER;
3250 }
3251 assert((flags & 0xFF000000) == 0, "unexpected flags");
3252 return flags;
3253 }
3254
3255 oop java_lang_ClassFrameInfo::classOrMemberName(oop obj) {
3256 return obj->obj_field(_classOrMemberName_offset);
3257 }
3258
3259 int java_lang_ClassFrameInfo::flags(oop obj) {
3260 return obj->int_field(_flags_offset);
3611 constructor->int_field_put(_modifiers_offset, value);
3612 }
3613
3614 void java_lang_reflect_Constructor::set_signature(oop constructor, oop value) {
3615 constructor->obj_field_put(_signature_offset, value);
3616 }
3617
3618 void java_lang_reflect_Constructor::set_annotations(oop constructor, oop value) {
3619 constructor->obj_field_put(_annotations_offset, value);
3620 }
3621
3622 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
3623 method->obj_field_put(_parameter_annotations_offset, value);
3624 }
3625
3626 int java_lang_reflect_Field::_clazz_offset;
3627 int java_lang_reflect_Field::_name_offset;
3628 int java_lang_reflect_Field::_type_offset;
3629 int java_lang_reflect_Field::_slot_offset;
3630 int java_lang_reflect_Field::_modifiers_offset;
3631 int java_lang_reflect_Field::_flags_offset;
3632 int java_lang_reflect_Field::_signature_offset;
3633 int java_lang_reflect_Field::_annotations_offset;
3634
3635 #define FIELD_FIELDS_DO(macro) \
3636 macro(_clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
3637 macro(_name_offset, k, vmSymbols::name_name(), string_signature, false); \
3638 macro(_type_offset, k, vmSymbols::type_name(), class_signature, false); \
3639 macro(_slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
3640 macro(_modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
3641 macro(_flags_offset, k, vmSymbols::flags_name(), int_signature, false); \
3642 macro(_signature_offset, k, vmSymbols::signature_name(), string_signature, false); \
3643 macro(_annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature, false);
3644
3645 void java_lang_reflect_Field::compute_offsets() {
3646 InstanceKlass* k = vmClasses::reflect_Field_klass();
3647 FIELD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3648 }
3649
3650 #if INCLUDE_CDS
3651 void java_lang_reflect_Field::serialize_offsets(SerializeClosure* f) {
3652 FIELD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3653 }
3654 #endif
3655
3656 Handle java_lang_reflect_Field::create(TRAPS) {
3657 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3658 Symbol* name = vmSymbols::java_lang_reflect_Field();
3659 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
3660 InstanceKlass* ik = InstanceKlass::cast(k);
3661 // Ensure it is initialized
3686 void java_lang_reflect_Field::set_type(oop field, oop value) {
3687 field->obj_field_put(_type_offset, value);
3688 }
3689
3690 int java_lang_reflect_Field::slot(oop reflect) {
3691 return reflect->int_field(_slot_offset);
3692 }
3693
3694 void java_lang_reflect_Field::set_slot(oop reflect, int value) {
3695 reflect->int_field_put(_slot_offset, value);
3696 }
3697
3698 int java_lang_reflect_Field::modifiers(oop field) {
3699 return field->int_field(_modifiers_offset);
3700 }
3701
3702 void java_lang_reflect_Field::set_modifiers(oop field, int value) {
3703 field->int_field_put(_modifiers_offset, value);
3704 }
3705
3706 void java_lang_reflect_Field::set_flags(oop field, int value) {
3707 field->int_field_put(_flags_offset, value);
3708 }
3709
3710 void java_lang_reflect_Field::set_signature(oop field, oop value) {
3711 field->obj_field_put(_signature_offset, value);
3712 }
3713
3714 void java_lang_reflect_Field::set_annotations(oop field, oop value) {
3715 field->obj_field_put(_annotations_offset, value);
3716 }
3717
3718 oop java_lang_reflect_RecordComponent::create(InstanceKlass* holder, RecordComponent* component, TRAPS) {
3719 // Allocate java.lang.reflect.RecordComponent instance
3720 HandleMark hm(THREAD);
3721 InstanceKlass* ik = vmClasses::RecordComponent_klass();
3722 assert(ik != nullptr, "must be loaded");
3723 ik->initialize(CHECK_NULL);
3724
3725 Handle element = ik->allocate_instance_handle(CHECK_NULL);
3726
3727 Handle decl_class(THREAD, holder->java_mirror());
3987 }
3988 #endif
3989
3990 bool java_lang_ref_Reference::is_referent_field(oop obj, ptrdiff_t offset) {
3991 assert(obj != nullptr, "sanity");
3992 if (offset != _referent_offset) {
3993 return false;
3994 }
3995
3996 Klass* k = obj->klass();
3997 if (!k->is_instance_klass()) {
3998 return false;
3999 }
4000
4001 InstanceKlass* ik = InstanceKlass::cast(obj->klass());
4002 bool is_reference = ik->reference_type() != REF_NONE;
4003 assert(!is_reference || ik->is_subclass_of(vmClasses::Reference_klass()), "sanity");
4004 return is_reference;
4005 }
4006
4007 int* java_lang_boxing_object::_offsets;
4008
4009 #define BOXING_FIELDS_DO(macro) \
4010 macro(java_lang_boxing_object::_offsets[T_BOOLEAN - T_BOOLEAN], vmClasses::Boolean_klass(), "value", bool_signature, false); \
4011 macro(java_lang_boxing_object::_offsets[T_CHAR - T_BOOLEAN], vmClasses::Character_klass(), "value", char_signature, false); \
4012 macro(java_lang_boxing_object::_offsets[T_FLOAT - T_BOOLEAN], vmClasses::Float_klass(), "value", float_signature, false); \
4013 macro(java_lang_boxing_object::_offsets[T_DOUBLE - T_BOOLEAN], vmClasses::Double_klass(), "value", double_signature, false); \
4014 macro(java_lang_boxing_object::_offsets[T_BYTE - T_BOOLEAN], vmClasses::Byte_klass(), "value", byte_signature, false); \
4015 macro(java_lang_boxing_object::_offsets[T_SHORT - T_BOOLEAN], vmClasses::Short_klass(), "value", short_signature, false); \
4016 macro(java_lang_boxing_object::_offsets[T_INT - T_BOOLEAN], vmClasses::Integer_klass(), "value", int_signature, false); \
4017 macro(java_lang_boxing_object::_offsets[T_LONG - T_BOOLEAN], vmClasses::Long_klass(), "value", long_signature, false);
4018
4019 void java_lang_boxing_object::compute_offsets() {
4020 assert(T_LONG - T_BOOLEAN == 7, "Sanity check");
4021 java_lang_boxing_object::_offsets = NEW_C_HEAP_ARRAY(int, 8, mtInternal);
4022 BOXING_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4023 }
4024
4025 #if INCLUDE_CDS
4026 void java_lang_boxing_object::serialize_offsets(SerializeClosure* f) {
4027 if (f->reading()) {
4028 assert(T_LONG - T_BOOLEAN == 7, "Sanity check");
4029 java_lang_boxing_object::_offsets = NEW_C_HEAP_ARRAY(int, 8, mtInternal);
4030 }
4031 BOXING_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4032 }
4033 #endif
4034
4035 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
4036 Klass* k = vmClasses::box_klass(type);
4037 if (k == nullptr) return nullptr;
4038 InstanceKlass* ik = InstanceKlass::cast(k);
4039 if (!ik->is_initialized()) {
4040 ik->initialize(CHECK_NULL);
4041 }
4042 return ik->allocate_instance(THREAD);
4043 }
4044
4045
4046 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
4047 oop box = initialize_and_allocate(type, CHECK_NULL);
4048 if (box == nullptr) return nullptr;
4049 switch (type) {
4050 case T_BOOLEAN:
4051 box->bool_field_put(value_offset(type), value->z);
4052 break;
4053 case T_CHAR:
4054 box->char_field_put(value_offset(type), value->c);
4055 break;
4056 case T_FLOAT:
4057 box->float_field_put(value_offset(type), value->f);
4058 break;
4059 case T_DOUBLE:
4060 box->double_field_put(value_offset(type), value->d);
4061 break;
4062 case T_BYTE:
4063 box->byte_field_put(value_offset(type), value->b);
4064 break;
4065 case T_SHORT:
4066 box->short_field_put(value_offset(type), value->s);
4067 break;
4068 case T_INT:
4069 box->int_field_put(value_offset(type), value->i);
4070 break;
4071 case T_LONG:
4072 box->long_field_put(value_offset(type), value->j);
4073 break;
4074 default:
4075 return nullptr;
4076 }
4077 return box;
4078 }
4079
4080
4081 BasicType java_lang_boxing_object::basic_type(oop box) {
4082 if (box == nullptr) return T_ILLEGAL;
4083 BasicType type = vmClasses::box_klass_type(box->klass());
4084 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt
4085 return T_ILLEGAL;
4086 return type;
4087 }
4088
4089
4090 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
4091 BasicType type = vmClasses::box_klass_type(box->klass());
4092 switch (type) {
4093 case T_BOOLEAN:
4094 value->z = box->bool_field(value_offset(type));
4095 break;
4096 case T_CHAR:
4097 value->c = box->char_field(value_offset(type));
4098 break;
4099 case T_FLOAT:
4100 value->f = box->float_field(value_offset(type));
4101 break;
4102 case T_DOUBLE:
4103 value->d = box->double_field(value_offset(type));
4104 break;
4105 case T_BYTE:
4106 value->b = box->byte_field(value_offset(type));
4107 break;
4108 case T_SHORT:
4109 value->s = box->short_field(value_offset(type));
4110 break;
4111 case T_INT:
4112 value->i = box->int_field(value_offset(type));
4113 break;
4114 case T_LONG:
4115 value->j = box->long_field(value_offset(type));
4116 break;
4117 default:
4118 return T_ILLEGAL;
4119 } // end switch
4120 return type;
4121 }
4122
4123
4124 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
4125 BasicType type = vmClasses::box_klass_type(box->klass());
4126 switch (type) {
4127 case T_BOOLEAN:
4128 box->bool_field_put(value_offset(type), value->z);
4129 break;
4130 case T_CHAR:
4131 box->char_field_put(value_offset(type), value->c);
4132 break;
4133 case T_FLOAT:
4134 box->float_field_put(value_offset(type), value->f);
4135 break;
4136 case T_DOUBLE:
4137 box->double_field_put(value_offset(type), value->d);
4138 break;
4139 case T_BYTE:
4140 box->byte_field_put(value_offset(type), value->b);
4141 break;
4142 case T_SHORT:
4143 box->short_field_put(value_offset(type), value->s);
4144 break;
4145 case T_INT:
4146 box->int_field_put(value_offset(type), value->i);
4147 break;
4148 case T_LONG:
4149 box->long_field_put(value_offset(type), value->j);
4150 break;
4151 default:
4152 return T_ILLEGAL;
4153 } // end switch
4154 return type;
4155 }
4156
4157
4158 void java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream* st) {
4159 switch (type) {
4160 case T_BOOLEAN: st->print("%s", value->z ? "true" : "false"); break;
4161 case T_CHAR: st->print("%d", value->c); break;
4162 case T_BYTE: st->print("%d", value->b); break;
4163 case T_SHORT: st->print("%d", value->s); break;
4164 case T_INT: st->print("%d", value->i); break;
4165 case T_LONG: st->print(JLONG_FORMAT, value->j); break;
4166 case T_FLOAT: st->print("%f", value->f); break;
4167 case T_DOUBLE: st->print("%lf", value->d); break;
4168 default: st->print("type %d?", type); break;
4169 }
4449
4450 #define CallConv_FIELDS_DO(macro) \
4451 macro(_argRegs_offset, k, "argRegs", jdk_internal_foreign_abi_VMStorage_array_signature, false); \
4452 macro(_retRegs_offset, k, "retRegs", jdk_internal_foreign_abi_VMStorage_array_signature, false); \
4453
4454 bool jdk_internal_foreign_abi_CallConv::is_instance(oop obj) {
4455 return obj != nullptr && is_subclass(obj->klass());
4456 }
4457
4458 void jdk_internal_foreign_abi_CallConv::compute_offsets() {
4459 InstanceKlass* k = vmClasses::CallConv_klass();
4460 CallConv_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4461 }
4462
4463 #if INCLUDE_CDS
4464 void jdk_internal_foreign_abi_CallConv::serialize_offsets(SerializeClosure* f) {
4465 CallConv_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4466 }
4467 #endif
4468
4469 refArrayOop jdk_internal_foreign_abi_CallConv::argRegs(oop entry) {
4470 return oop_cast<refArrayOop>(entry->obj_field(_argRegs_offset));
4471 }
4472
4473 refArrayOop jdk_internal_foreign_abi_CallConv::retRegs(oop entry) {
4474 return oop_cast<refArrayOop>(entry->obj_field(_retRegs_offset));
4475 }
4476
4477 oop java_lang_invoke_MethodHandle::type(oop mh) {
4478 return mh->obj_field(_type_offset);
4479 }
4480
4481 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
4482 mh->obj_field_put(_type_offset, mtype);
4483 }
4484
4485 oop java_lang_invoke_MethodHandle::form(oop mh) {
4486 assert(_form_offset != 0, "");
4487 return mh->obj_field(_form_offset);
4488 }
4489
4490 void java_lang_invoke_MethodHandle::set_form(oop mh, oop lform) {
4491 assert(_form_offset != 0, "");
4492 mh->obj_field_put(_form_offset, lform);
4493 }
4494
4517 oop java_lang_invoke_MemberName::type(oop mname) {
4518 assert(is_instance(mname), "wrong type");
4519 return mname->obj_field(_type_offset);
4520 }
4521
4522 void java_lang_invoke_MemberName::set_type(oop mname, oop type) {
4523 assert(is_instance(mname), "wrong type");
4524 mname->obj_field_put(_type_offset, type);
4525 }
4526
4527 int java_lang_invoke_MemberName::flags(oop mname) {
4528 assert(is_instance(mname), "wrong type");
4529 return mname->int_field(_flags_offset);
4530 }
4531
4532 void java_lang_invoke_MemberName::set_flags(oop mname, int flags) {
4533 assert(is_instance(mname), "wrong type");
4534 mname->int_field_put(_flags_offset, flags);
4535 }
4536
4537 // Return vmtarget from ResolvedMethodName method field through indirection
4538 Method* java_lang_invoke_MemberName::vmtarget(oop mname) {
4539 assert(is_instance(mname), "wrong type");
4540 oop method = mname->obj_field(_method_offset);
4541 return method == nullptr ? nullptr : java_lang_invoke_ResolvedMethodName::vmtarget(method);
4542 }
4543
4544 bool java_lang_invoke_MemberName::is_method(oop mname) {
4545 assert(is_instance(mname), "must be MemberName");
4546 return (flags(mname) & (MN_IS_METHOD | MN_IS_OBJECT_CONSTRUCTOR)) > 0;
4547 }
4548
4549 void java_lang_invoke_MemberName::set_method(oop mname, oop resolved_method) {
4550 assert(is_instance(mname), "wrong type");
4551 mname->obj_field_put(_method_offset, resolved_method);
4552 }
4553
4554 intptr_t java_lang_invoke_MemberName::vmindex(oop mname) {
4555 assert(is_instance(mname), "wrong type");
4556 return (intptr_t) mname->address_field(_vmindex_offset);
4557 }
4558
4559 void java_lang_invoke_MemberName::set_vmindex(oop mname, intptr_t index) {
4560 assert(is_instance(mname), "wrong type");
4561 mname->address_field_put(_vmindex_offset, (address) index);
4562 }
4563
4564
4565 Method* java_lang_invoke_ResolvedMethodName::vmtarget(oop resolved_method) {
4566 assert(is_instance(resolved_method), "wrong type");
5519 if (!ik->find_local_field(f_name, f_sig, &fd)) {
5520 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
5521 return false;
5522 }
5523 if (fd.is_static()) {
5524 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);
5525 return false;
5526 }
5527 if (fd.offset() == deserialized_offset ) {
5528 return true;
5529 } else {
5530 tty->print_cr("Offset of nonstatic field %s.%s is deserialized as %d but should really be %d.",
5531 klass_name, field_name, deserialized_offset, fd.offset());
5532 return false;
5533 }
5534 }
5535
5536 void JavaClasses::check_offsets() {
5537 bool valid = true;
5538
5539 #define CHECK_OFFSET(klass_name, type, field_sig) \
5540 valid &= check_offset(klass_name, java_lang_boxing_object::value_offset(type), "value", field_sig)
5541
5542 CHECK_OFFSET("java/lang/Boolean", T_BOOLEAN, "Z");
5543 CHECK_OFFSET("java/lang/Character", T_CHAR, "C");
5544 CHECK_OFFSET("java/lang/Float", T_FLOAT, "F");
5545 CHECK_OFFSET("java/lang/Double", T_DOUBLE, "D");
5546 CHECK_OFFSET("java/lang/Byte", T_BYTE, "B");
5547 CHECK_OFFSET("java/lang/Short", T_SHORT, "S");
5548 CHECK_OFFSET("java/lang/Integer", T_INT, "I");
5549 CHECK_OFFSET("java/lang/Long", T_LONG, "J");
5550
5551 if (!valid) vm_exit_during_initialization("Field offset verification failed");
5552 }
5553
5554 #endif // PRODUCT
5555
5556 int InjectedField::compute_offset() {
5557 InstanceKlass* ik = klass();
5558 for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
5559 if (!may_be_java && !fs.field_flags().is_injected()) {
5560 // Only look at injected fields
5561 continue;
5562 }
5563 if (fs.name() == name() && fs.signature() == signature()) {
5564 return fs.offset();
5565 }
5566 }
5567 ResourceMark rm;
5568 tty->print_cr("Invalid layout of %s at %s/%s%s", ik->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : "");
5569 #ifndef PRODUCT
|