21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/classFileStream.hpp"
27 #include "classfile/classListParser.hpp"
28 #include "classfile/classLoader.hpp"
29 #include "classfile/classLoaderData.inline.hpp"
30 #include "classfile/classLoaderDataGraph.hpp"
31 #include "classfile/classLoaderExt.hpp"
32 #include "classfile/dictionary.hpp"
33 #include "classfile/javaClasses.hpp"
34 #include "classfile/symbolTable.hpp"
35 #include "classfile/systemDictionary.hpp"
36 #include "classfile/systemDictionaryShared.hpp"
37 #include "classfile/verificationType.hpp"
38 #include "classfile/vmSymbols.hpp"
39 #include "logging/log.hpp"
40 #include "memory/allocation.hpp"
41 #include "memory/filemap.hpp"
42 #include "memory/metadataFactory.hpp"
43 #include "memory/metaspaceClosure.hpp"
44 #include "memory/oopFactory.hpp"
45 #include "memory/resourceArea.hpp"
46 #include "memory/universe.hpp"
47 #include "memory/dynamicArchive.hpp"
48 #include "oops/instanceKlass.hpp"
49 #include "oops/klass.inline.hpp"
50 #include "oops/objArrayOop.inline.hpp"
51 #include "oops/oop.inline.hpp"
52 #include "oops/typeArrayOop.inline.hpp"
53 #include "runtime/handles.inline.hpp"
54 #include "runtime/java.hpp"
55 #include "runtime/javaCalls.hpp"
56 #include "runtime/mutexLocker.hpp"
57 #include "utilities/hashtable.inline.hpp"
58 #include "utilities/resourceHash.hpp"
59 #include "utilities/stringUtils.hpp"
60
277 CrcInfo* c = crc();
278 c->_clsfile_size = info._clsfile_size;
279 c->_clsfile_crc32 = info._clsfile_crc32;
280 }
281 _num_constraints = info.num_constraints();
282 if (_num_constraints > 0) {
283 RTConstraint* constraints = verifier_constraints();
284 char* flags = verifier_constraint_flags();
285 int i;
286 for (i = 0; i < _num_constraints; i++) {
287 constraints[i]._name = object_delta_u4(info._verifier_constraints->at(i)._name);
288 constraints[i]._from_name = object_delta_u4(info._verifier_constraints->at(i)._from_name);
289 }
290 for (i = 0; i < _num_constraints; i++) {
291 flags[i] = info._verifier_constraint_flags->at(i);
292 }
293 }
294 if (DynamicDumpSharedSpaces) {
295 _klass = DynamicArchive::original_to_target(info._klass);
296 }
297 }
298
299 bool matches(int clsfile_size, int clsfile_crc32) const {
300 return crc()->_clsfile_size == clsfile_size &&
301 crc()->_clsfile_crc32 == clsfile_crc32;
302 }
303
304 Symbol* get_constraint_name(int i) {
305 return (Symbol*)(SharedBaseAddress + verifier_constraint_at(i)->_name);
306 }
307 Symbol* get_constraint_from_name(int i) {
308 return (Symbol*)(SharedBaseAddress + verifier_constraint_at(i)->_from_name);
309 }
310
311 char get_constraint_flag(int i) {
312 check_constraint_offset(i);
313 return verifier_constraint_flags()[i];
314 }
315
316 private:
320 // building a new hashtable.
321 //
322 // info_pointer_addr(klass) --> 0x0100 RunTimeSharedClassInfo*
323 // InstanceKlass* klass --> 0x0108 <C++ vtbl>
324 // 0x0110 fields from Klass ...
325 static RunTimeSharedClassInfo** info_pointer_addr(InstanceKlass* klass) {
326 return &((RunTimeSharedClassInfo**)klass)[-1];
327 }
328
329 public:
330 static RunTimeSharedClassInfo* get_for(InstanceKlass* klass) {
331 return *info_pointer_addr(klass);
332 }
333 static void set_for(InstanceKlass* klass, RunTimeSharedClassInfo* record) {
334 if (DynamicDumpSharedSpaces) {
335 klass = DynamicArchive::original_to_buffer(klass);
336 *info_pointer_addr(klass) = DynamicArchive::buffer_to_target(record);
337 } else {
338 *info_pointer_addr(klass) = record;
339 }
340 }
341
342 // Used by RunTimeSharedDictionary to implement OffsetCompactHashtable::EQUALS
343 static inline bool EQUALS(
344 const RunTimeSharedClassInfo* value, Symbol* key, int len_unused) {
345 return (value->_klass->name() == key);
346 }
347 };
348
349 class RunTimeSharedDictionary : public OffsetCompactHashtable<
350 Symbol*,
351 const RunTimeSharedClassInfo*,
352 RunTimeSharedClassInfo::EQUALS> {};
353
354 static DumpTimeSharedClassTable* _dumptime_table = NULL;
355 // SystemDictionaries in the base layer static archive
356 static RunTimeSharedDictionary _builtin_dictionary;
357 static RunTimeSharedDictionary _unregistered_dictionary;
358 // SystemDictionaries in the top layer dynamic archive
359 static RunTimeSharedDictionary _dynamic_builtin_dictionary;
1337 CompactHashtableWriter* _writer;
1338 bool _is_builtin;
1339 public:
1340 CopySharedClassInfoToArchive(CompactHashtableWriter* writer,
1341 bool is_builtin,
1342 bool is_static_archive)
1343 : _writer(writer), _is_builtin(is_builtin) {}
1344
1345 bool do_entry(InstanceKlass* k, DumpTimeSharedClassInfo& info) {
1346 if (!info.is_excluded() && info.is_builtin() == _is_builtin) {
1347 size_t byte_size = RunTimeSharedClassInfo::byte_size(info._klass, info.num_constraints());
1348 RunTimeSharedClassInfo* record;
1349 record = (RunTimeSharedClassInfo*)MetaspaceShared::read_only_space_alloc(byte_size);
1350 record->init(info);
1351
1352 unsigned int hash;
1353 Symbol* name = info._klass->name();
1354 if (DynamicDumpSharedSpaces) {
1355 name = DynamicArchive::original_to_target(name);
1356 }
1357 hash = primitive_hash<Symbol*>(name);
1358 u4 delta;
1359 if (DynamicDumpSharedSpaces) {
1360 delta = MetaspaceShared::object_delta_u4(DynamicArchive::buffer_to_target(record));
1361 } else {
1362 delta = MetaspaceShared::object_delta_u4(record);
1363 }
1364 _writer->add(hash, delta);
1365 if (log_is_enabled(Trace, cds, hashtables)) {
1366 ResourceMark rm;
1367 log_trace(cds,hashtables)("%s dictionary: %s", (_is_builtin ? "builtin" : "unregistered"), info._klass->external_name());
1368 }
1369
1370 // Save this for quick runtime lookup of InstanceKlass* -> RunTimeSharedClassInfo*
1371 RunTimeSharedClassInfo::set_for(info._klass, record);
1372 }
1373 return true; // keep on iterating
1374 }
1375 };
1376
1377 void SystemDictionaryShared::write_dictionary(RunTimeSharedDictionary* dictionary,
1396 }
1397
1398 void SystemDictionaryShared::serialize_dictionary_headers(SerializeClosure* soc,
1399 bool is_static_archive) {
1400 if (is_static_archive) {
1401 _builtin_dictionary.serialize_header(soc);
1402 _unregistered_dictionary.serialize_header(soc);
1403 } else {
1404 _dynamic_builtin_dictionary.serialize_header(soc);
1405 _dynamic_unregistered_dictionary.serialize_header(soc);
1406 }
1407 }
1408
1409 const RunTimeSharedClassInfo*
1410 SystemDictionaryShared::find_record(RunTimeSharedDictionary* static_dict, RunTimeSharedDictionary* dynamic_dict, Symbol* name) {
1411 if (!UseSharedSpaces || !name->is_shared()) {
1412 // The names of all shared classes must also be a shared Symbol.
1413 return NULL;
1414 }
1415
1416 unsigned int hash = primitive_hash<Symbol*>(name);
1417 const RunTimeSharedClassInfo* record = NULL;
1418 if (!MetaspaceShared::is_shared_dynamic(name)) {
1419 // The names of all shared classes in the static dict must also be in the
1420 // static archive
1421 record = static_dict->lookup(name, hash, 0);
1422 }
1423
1424 if (record == NULL && DynamicArchive::is_mapped()) {
1425 record = dynamic_dict->lookup(name, hash, 0);
1426 }
1427
1428 return record;
1429 }
1430
1431 InstanceKlass* SystemDictionaryShared::find_builtin_class(Symbol* name) {
1432 const RunTimeSharedClassInfo* record = find_record(&_builtin_dictionary, &_dynamic_builtin_dictionary, name);
1433 if (record != NULL) {
1434 return record->_klass;
1435 } else {
1436 return NULL;
|
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/classFileStream.hpp"
27 #include "classfile/classListParser.hpp"
28 #include "classfile/classLoader.hpp"
29 #include "classfile/classLoaderData.inline.hpp"
30 #include "classfile/classLoaderDataGraph.hpp"
31 #include "classfile/classLoaderExt.hpp"
32 #include "classfile/dictionary.hpp"
33 #include "classfile/javaClasses.hpp"
34 #include "classfile/symbolTable.hpp"
35 #include "classfile/systemDictionary.hpp"
36 #include "classfile/systemDictionaryShared.hpp"
37 #include "classfile/verificationType.hpp"
38 #include "classfile/vmSymbols.hpp"
39 #include "logging/log.hpp"
40 #include "memory/allocation.hpp"
41 #include "memory/archiveUtils.hpp"
42 #include "memory/filemap.hpp"
43 #include "memory/metadataFactory.hpp"
44 #include "memory/metaspaceClosure.hpp"
45 #include "memory/oopFactory.hpp"
46 #include "memory/resourceArea.hpp"
47 #include "memory/universe.hpp"
48 #include "memory/dynamicArchive.hpp"
49 #include "oops/instanceKlass.hpp"
50 #include "oops/klass.inline.hpp"
51 #include "oops/objArrayOop.inline.hpp"
52 #include "oops/oop.inline.hpp"
53 #include "oops/typeArrayOop.inline.hpp"
54 #include "runtime/handles.inline.hpp"
55 #include "runtime/java.hpp"
56 #include "runtime/javaCalls.hpp"
57 #include "runtime/mutexLocker.hpp"
58 #include "utilities/hashtable.inline.hpp"
59 #include "utilities/resourceHash.hpp"
60 #include "utilities/stringUtils.hpp"
61
278 CrcInfo* c = crc();
279 c->_clsfile_size = info._clsfile_size;
280 c->_clsfile_crc32 = info._clsfile_crc32;
281 }
282 _num_constraints = info.num_constraints();
283 if (_num_constraints > 0) {
284 RTConstraint* constraints = verifier_constraints();
285 char* flags = verifier_constraint_flags();
286 int i;
287 for (i = 0; i < _num_constraints; i++) {
288 constraints[i]._name = object_delta_u4(info._verifier_constraints->at(i)._name);
289 constraints[i]._from_name = object_delta_u4(info._verifier_constraints->at(i)._from_name);
290 }
291 for (i = 0; i < _num_constraints; i++) {
292 flags[i] = info._verifier_constraint_flags->at(i);
293 }
294 }
295 if (DynamicDumpSharedSpaces) {
296 _klass = DynamicArchive::original_to_target(info._klass);
297 }
298 ArchivePtrMarker::mark_pointer(&_klass);
299 }
300
301 bool matches(int clsfile_size, int clsfile_crc32) const {
302 return crc()->_clsfile_size == clsfile_size &&
303 crc()->_clsfile_crc32 == clsfile_crc32;
304 }
305
306 Symbol* get_constraint_name(int i) {
307 return (Symbol*)(SharedBaseAddress + verifier_constraint_at(i)->_name);
308 }
309 Symbol* get_constraint_from_name(int i) {
310 return (Symbol*)(SharedBaseAddress + verifier_constraint_at(i)->_from_name);
311 }
312
313 char get_constraint_flag(int i) {
314 check_constraint_offset(i);
315 return verifier_constraint_flags()[i];
316 }
317
318 private:
322 // building a new hashtable.
323 //
324 // info_pointer_addr(klass) --> 0x0100 RunTimeSharedClassInfo*
325 // InstanceKlass* klass --> 0x0108 <C++ vtbl>
326 // 0x0110 fields from Klass ...
327 static RunTimeSharedClassInfo** info_pointer_addr(InstanceKlass* klass) {
328 return &((RunTimeSharedClassInfo**)klass)[-1];
329 }
330
331 public:
332 static RunTimeSharedClassInfo* get_for(InstanceKlass* klass) {
333 return *info_pointer_addr(klass);
334 }
335 static void set_for(InstanceKlass* klass, RunTimeSharedClassInfo* record) {
336 if (DynamicDumpSharedSpaces) {
337 klass = DynamicArchive::original_to_buffer(klass);
338 *info_pointer_addr(klass) = DynamicArchive::buffer_to_target(record);
339 } else {
340 *info_pointer_addr(klass) = record;
341 }
342
343 ArchivePtrMarker::mark_pointer(info_pointer_addr(klass));
344 }
345
346 // Used by RunTimeSharedDictionary to implement OffsetCompactHashtable::EQUALS
347 static inline bool EQUALS(
348 const RunTimeSharedClassInfo* value, Symbol* key, int len_unused) {
349 return (value->_klass->name() == key);
350 }
351 };
352
353 class RunTimeSharedDictionary : public OffsetCompactHashtable<
354 Symbol*,
355 const RunTimeSharedClassInfo*,
356 RunTimeSharedClassInfo::EQUALS> {};
357
358 static DumpTimeSharedClassTable* _dumptime_table = NULL;
359 // SystemDictionaries in the base layer static archive
360 static RunTimeSharedDictionary _builtin_dictionary;
361 static RunTimeSharedDictionary _unregistered_dictionary;
362 // SystemDictionaries in the top layer dynamic archive
363 static RunTimeSharedDictionary _dynamic_builtin_dictionary;
1341 CompactHashtableWriter* _writer;
1342 bool _is_builtin;
1343 public:
1344 CopySharedClassInfoToArchive(CompactHashtableWriter* writer,
1345 bool is_builtin,
1346 bool is_static_archive)
1347 : _writer(writer), _is_builtin(is_builtin) {}
1348
1349 bool do_entry(InstanceKlass* k, DumpTimeSharedClassInfo& info) {
1350 if (!info.is_excluded() && info.is_builtin() == _is_builtin) {
1351 size_t byte_size = RunTimeSharedClassInfo::byte_size(info._klass, info.num_constraints());
1352 RunTimeSharedClassInfo* record;
1353 record = (RunTimeSharedClassInfo*)MetaspaceShared::read_only_space_alloc(byte_size);
1354 record->init(info);
1355
1356 unsigned int hash;
1357 Symbol* name = info._klass->name();
1358 if (DynamicDumpSharedSpaces) {
1359 name = DynamicArchive::original_to_target(name);
1360 }
1361 hash = SystemDictionaryShared::hash_for_shared_dictionary(name);
1362 u4 delta;
1363 if (DynamicDumpSharedSpaces) {
1364 delta = MetaspaceShared::object_delta_u4(DynamicArchive::buffer_to_target(record));
1365 } else {
1366 delta = MetaspaceShared::object_delta_u4(record);
1367 }
1368 _writer->add(hash, delta);
1369 if (log_is_enabled(Trace, cds, hashtables)) {
1370 ResourceMark rm;
1371 log_trace(cds,hashtables)("%s dictionary: %s", (_is_builtin ? "builtin" : "unregistered"), info._klass->external_name());
1372 }
1373
1374 // Save this for quick runtime lookup of InstanceKlass* -> RunTimeSharedClassInfo*
1375 RunTimeSharedClassInfo::set_for(info._klass, record);
1376 }
1377 return true; // keep on iterating
1378 }
1379 };
1380
1381 void SystemDictionaryShared::write_dictionary(RunTimeSharedDictionary* dictionary,
1400 }
1401
1402 void SystemDictionaryShared::serialize_dictionary_headers(SerializeClosure* soc,
1403 bool is_static_archive) {
1404 if (is_static_archive) {
1405 _builtin_dictionary.serialize_header(soc);
1406 _unregistered_dictionary.serialize_header(soc);
1407 } else {
1408 _dynamic_builtin_dictionary.serialize_header(soc);
1409 _dynamic_unregistered_dictionary.serialize_header(soc);
1410 }
1411 }
1412
1413 const RunTimeSharedClassInfo*
1414 SystemDictionaryShared::find_record(RunTimeSharedDictionary* static_dict, RunTimeSharedDictionary* dynamic_dict, Symbol* name) {
1415 if (!UseSharedSpaces || !name->is_shared()) {
1416 // The names of all shared classes must also be a shared Symbol.
1417 return NULL;
1418 }
1419
1420 unsigned int hash = SystemDictionaryShared::hash_for_shared_dictionary(name);
1421 const RunTimeSharedClassInfo* record = NULL;
1422 if (!MetaspaceShared::is_shared_dynamic(name)) {
1423 // The names of all shared classes in the static dict must also be in the
1424 // static archive
1425 record = static_dict->lookup(name, hash, 0);
1426 }
1427
1428 if (record == NULL && DynamicArchive::is_mapped()) {
1429 record = dynamic_dict->lookup(name, hash, 0);
1430 }
1431
1432 return record;
1433 }
1434
1435 InstanceKlass* SystemDictionaryShared::find_builtin_class(Symbol* name) {
1436 const RunTimeSharedClassInfo* record = find_record(&_builtin_dictionary, &_dynamic_builtin_dictionary, name);
1437 if (record != NULL) {
1438 return record->_klass;
1439 } else {
1440 return NULL;
|