< prev index next >

src/hotspot/share/classfile/javaClasses.cpp

Print this page

1320 }
1321 void java_lang_Class::set_init_lock(oop java_class, oop init_lock) {
1322   assert(_init_lock_offset != 0, "must be set");
1323   java_class->obj_field_put(_init_lock_offset, init_lock);
1324 }
1325 
1326 objArrayOop java_lang_Class::signers(oop java_class) {
1327   assert(_signers_offset != 0, "must be set");
1328   return (objArrayOop)java_class->obj_field(_signers_offset);
1329 }
1330 
1331 oop java_lang_Class::class_data(oop java_class) {
1332   assert(_classData_offset != 0, "must be set");
1333   return java_class->obj_field(_classData_offset);
1334 }
1335 void java_lang_Class::set_class_data(oop java_class, oop class_data) {
1336   assert(_classData_offset != 0, "must be set");
1337   java_class->obj_field_put(_classData_offset, class_data);
1338 }
1339 









1340 void java_lang_Class::set_reflection_data(oop java_class, oop reflection_data) {
1341   assert(_reflectionData_offset != 0, "must be set");
1342   java_class->obj_field_put(_reflectionData_offset, reflection_data);
1343 }
1344 
1345 void java_lang_Class::set_class_loader(oop java_class, oop loader) {
1346   assert(_class_loader_offset != 0, "offsets should have been initialized");
1347   java_class->obj_field_put(_class_loader_offset, loader);
1348 }
1349 
1350 oop java_lang_Class::class_loader(oop java_class) {
1351   assert(_class_loader_offset != 0, "must be set");
1352   return java_class->obj_field(_class_loader_offset);
1353 }
1354 
1355 oop java_lang_Class::module(oop java_class) {
1356   assert(_module_offset != 0, "must be set");
1357   return java_class->obj_field(_module_offset);
1358 }
1359 

1524       (*reference_klass) = as_Klass(java_class);
1525     return T_OBJECT;
1526   }
1527 }
1528 
1529 
1530 oop java_lang_Class::primitive_mirror(BasicType t) {
1531   oop mirror = Universe::java_mirror(t);
1532   assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
1533   assert(is_primitive(mirror), "must be primitive");
1534   return mirror;
1535 }
1536 
1537 #define CLASS_FIELDS_DO(macro) \
1538   macro(_classRedefinedCount_offset, k, "classRedefinedCount", int_signature,          false); \
1539   macro(_class_loader_offset,        k, "classLoader",         classloader_signature,  false); \
1540   macro(_component_mirror_offset,    k, "componentType",       class_signature,        false); \
1541   macro(_module_offset,              k, "module",              module_signature,       false); \
1542   macro(_name_offset,                k, "name",                string_signature,       false); \
1543   macro(_classData_offset,           k, "classData",           object_signature,       false); \
1544   macro(_reflectionData_offset,      k, "reflectionData",      java_lang_ref_SoftReference_signature, false); \
1545   macro(_signers_offset,             k, "signers",             object_array_signature, false); \
1546   macro(_modifiers_offset,           k, vmSymbols::modifiers_name(), char_signature,    false); \
1547   macro(_raw_access_flags_offset,    k, "classFileAccessFlags",      char_signature,    false); \
1548   macro(_protection_domain_offset,   k, "protectionDomain",    java_security_ProtectionDomain_signature,  false); \
1549   macro(_is_primitive_offset,        k, "primitive",           bool_signature,         false);
1550 
1551 void java_lang_Class::compute_offsets() {
1552   if (_offsets_computed) {
1553     return;
1554   }
1555 
1556   _offsets_computed = true;
1557 
1558   InstanceKlass* k = vmClasses::Class_klass();
1559   CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1560   CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1561 }
1562 
1563 #if INCLUDE_CDS
1564 void java_lang_Class::serialize_offsets(SerializeClosure* f) {

2342   return msg_utf8;
2343 }
2344 
2345 oop java_lang_Throwable::cause(oop throwable) {
2346   return throwable->obj_field(_cause_offset);
2347 }
2348 
2349 void java_lang_Throwable::set_message(oop throwable, oop value) {
2350   throwable->obj_field_put(_detailMessage_offset, value);
2351 }
2352 
2353 
2354 void java_lang_Throwable::set_stacktrace(oop throwable, oop st_element_array) {
2355   throwable->obj_field_put(_stackTrace_offset, st_element_array);
2356 }
2357 
2358 void java_lang_Throwable::clear_stacktrace(oop throwable) {
2359   set_stacktrace(throwable, nullptr);
2360 }
2361 




2362 
2363 void java_lang_Throwable::print(oop throwable, outputStream* st) {
2364   ResourceMark rm;
2365   Klass* k = throwable->klass();
2366   assert(k != nullptr, "just checking");
2367   st->print("%s", k->external_name());
2368   oop msg = message(throwable);
2369   if (msg != nullptr) {
2370     st->print(": %s", java_lang_String::as_utf8_string(msg));
2371   }
2372 }
2373 
2374 // After this many redefines, the stack trace is unreliable.
2375 const int MAX_VERSION = USHRT_MAX;
2376 
2377 static inline bool version_matches(Method* method, int version) {
2378   assert(version < MAX_VERSION, "version is too big");
2379   return method != nullptr && (method->constants()->version() == version);
2380 }
2381 

1320 }
1321 void java_lang_Class::set_init_lock(oop java_class, oop init_lock) {
1322   assert(_init_lock_offset != 0, "must be set");
1323   java_class->obj_field_put(_init_lock_offset, init_lock);
1324 }
1325 
1326 objArrayOop java_lang_Class::signers(oop java_class) {
1327   assert(_signers_offset != 0, "must be set");
1328   return (objArrayOop)java_class->obj_field(_signers_offset);
1329 }
1330 
1331 oop java_lang_Class::class_data(oop java_class) {
1332   assert(_classData_offset != 0, "must be set");
1333   return java_class->obj_field(_classData_offset);
1334 }
1335 void java_lang_Class::set_class_data(oop java_class, oop class_data) {
1336   assert(_classData_offset != 0, "must be set");
1337   java_class->obj_field_put(_classData_offset, class_data);
1338 }
1339 
1340 oop java_lang_Class::reflection_data(oop java_class) {
1341   assert(_reflectionData_offset != 0, "must be set");
1342   return java_class->obj_field(_reflectionData_offset);
1343 }
1344 
1345 bool java_lang_Class::has_reflection_data(oop java_class) {
1346   return (java_lang_Class::reflection_data(java_class) != nullptr);
1347 }
1348 
1349 void java_lang_Class::set_reflection_data(oop java_class, oop reflection_data) {
1350   assert(_reflectionData_offset != 0, "must be set");
1351   java_class->obj_field_put(_reflectionData_offset, reflection_data);
1352 }
1353 
1354 void java_lang_Class::set_class_loader(oop java_class, oop loader) {
1355   assert(_class_loader_offset != 0, "offsets should have been initialized");
1356   java_class->obj_field_put(_class_loader_offset, loader);
1357 }
1358 
1359 oop java_lang_Class::class_loader(oop java_class) {
1360   assert(_class_loader_offset != 0, "must be set");
1361   return java_class->obj_field(_class_loader_offset);
1362 }
1363 
1364 oop java_lang_Class::module(oop java_class) {
1365   assert(_module_offset != 0, "must be set");
1366   return java_class->obj_field(_module_offset);
1367 }
1368 

1533       (*reference_klass) = as_Klass(java_class);
1534     return T_OBJECT;
1535   }
1536 }
1537 
1538 
1539 oop java_lang_Class::primitive_mirror(BasicType t) {
1540   oop mirror = Universe::java_mirror(t);
1541   assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
1542   assert(is_primitive(mirror), "must be primitive");
1543   return mirror;
1544 }
1545 
1546 #define CLASS_FIELDS_DO(macro) \
1547   macro(_classRedefinedCount_offset, k, "classRedefinedCount", int_signature,          false); \
1548   macro(_class_loader_offset,        k, "classLoader",         classloader_signature,  false); \
1549   macro(_component_mirror_offset,    k, "componentType",       class_signature,        false); \
1550   macro(_module_offset,              k, "module",              module_signature,       false); \
1551   macro(_name_offset,                k, "name",                string_signature,       false); \
1552   macro(_classData_offset,           k, "classData",           object_signature,       false); \
1553   macro(_reflectionData_offset,      k, "reflectionData",      class_ReflectionData_signature, false); \
1554   macro(_signers_offset,             k, "signers",             object_array_signature, false); \
1555   macro(_modifiers_offset,           k, vmSymbols::modifiers_name(), char_signature,    false); \
1556   macro(_raw_access_flags_offset,    k, "classFileAccessFlags",      char_signature,    false); \
1557   macro(_protection_domain_offset,   k, "protectionDomain",    java_security_ProtectionDomain_signature,  false); \
1558   macro(_is_primitive_offset,        k, "primitive",           bool_signature,         false);
1559 
1560 void java_lang_Class::compute_offsets() {
1561   if (_offsets_computed) {
1562     return;
1563   }
1564 
1565   _offsets_computed = true;
1566 
1567   InstanceKlass* k = vmClasses::Class_klass();
1568   CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1569   CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1570 }
1571 
1572 #if INCLUDE_CDS
1573 void java_lang_Class::serialize_offsets(SerializeClosure* f) {

2351   return msg_utf8;
2352 }
2353 
2354 oop java_lang_Throwable::cause(oop throwable) {
2355   return throwable->obj_field(_cause_offset);
2356 }
2357 
2358 void java_lang_Throwable::set_message(oop throwable, oop value) {
2359   throwable->obj_field_put(_detailMessage_offset, value);
2360 }
2361 
2362 
2363 void java_lang_Throwable::set_stacktrace(oop throwable, oop st_element_array) {
2364   throwable->obj_field_put(_stackTrace_offset, st_element_array);
2365 }
2366 
2367 void java_lang_Throwable::clear_stacktrace(oop throwable) {
2368   set_stacktrace(throwable, nullptr);
2369 }
2370 
2371 oop java_lang_Throwable::create_exception_instance(Symbol* class_name, TRAPS) {
2372   Klass* k = SystemDictionary::resolve_or_fail(class_name, true, CHECK_NULL);
2373   return InstanceKlass::cast(k)->allocate_instance(CHECK_NULL);
2374 }
2375 
2376 void java_lang_Throwable::print(oop throwable, outputStream* st) {
2377   ResourceMark rm;
2378   Klass* k = throwable->klass();
2379   assert(k != nullptr, "just checking");
2380   st->print("%s", k->external_name());
2381   oop msg = message(throwable);
2382   if (msg != nullptr) {
2383     st->print(": %s", java_lang_String::as_utf8_string(msg));
2384   }
2385 }
2386 
2387 // After this many redefines, the stack trace is unreliable.
2388 const int MAX_VERSION = USHRT_MAX;
2389 
2390 static inline bool version_matches(Method* method, int version) {
2391   assert(version < MAX_VERSION, "version is too big");
2392   return method != nullptr && (method->constants()->version() == version);
2393 }
2394 
< prev index next >