64 #include "runtime/mutexLocker.hpp"
65 #include "runtime/os.hpp"
66 #include "runtime/vm_version.hpp"
67 #include "utilities/align.hpp"
68 #include "utilities/bitMap.inline.hpp"
69 #include "utilities/classpathStream.hpp"
70 #include "utilities/defaultStream.hpp"
71 #include "utilities/ostream.hpp"
72 #if INCLUDE_G1GC
73 #include "gc/g1/g1CollectedHeap.hpp"
74 #include "gc/g1/heapRegion.hpp"
75 #endif
76
77 # include <sys/stat.h>
78 # include <errno.h>
79
80 #ifndef O_BINARY // if defined (Win32) use binary files.
81 #define O_BINARY 0 // otherwise do nothing.
82 #endif
83
84 // Fill in the fileMapInfo structure with data about this VM instance.
85
86 // This method copies the vm version info into header_version. If the version is too
87 // long then a truncated version, which has a hash code appended to it, is copied.
88 //
89 // Using a template enables this method to verify that header_version is an array of
90 // length JVM_IDENT_MAX. This ensures that the code that writes to the CDS file and
91 // the code that reads the CDS file will both use the same size buffer. Hence, will
92 // use identical truncation. This is necessary for matching of truncated versions.
93 template <int N> static void get_header_version(char (&header_version) [N]) {
94 assert(N == JVM_IDENT_MAX, "Bad header_version size");
95
96 const char *vm_version = VM_Version::internal_vm_info_string();
97 const int version_len = (int)strlen(vm_version);
98
99 memset(header_version, 0, JVM_IDENT_MAX);
100
101 if (version_len < (JVM_IDENT_MAX-1)) {
102 strcpy(header_version, vm_version);
103
197 set_magic(CDSConfig::is_dumping_dynamic_archive() ? CDS_DYNAMIC_ARCHIVE_MAGIC : CDS_ARCHIVE_MAGIC);
198 set_version(CURRENT_CDS_ARCHIVE_VERSION);
199
200 if (!info->is_static() && base_archive_name_size != 0) {
201 // copy base archive name
202 copy_base_archive_name(CDSConfig::static_archive_path());
203 }
204 _core_region_alignment = core_region_alignment;
205 _obj_alignment = ObjectAlignmentInBytes;
206 _compact_strings = CompactStrings;
207 if (CDSConfig::is_dumping_heap()) {
208 _narrow_oop_mode = CompressedOops::mode();
209 _narrow_oop_base = CompressedOops::base();
210 _narrow_oop_shift = CompressedOops::shift();
211 }
212 _compressed_oops = UseCompressedOops;
213 _compressed_class_ptrs = UseCompressedClassPointers;
214 _max_heap_size = MaxHeapSize;
215 _use_optimized_module_handling = MetaspaceShared::use_optimized_module_handling();
216 _has_full_module_graph = CDSConfig::is_dumping_full_module_graph();
217
218 // The following fields are for sanity checks for whether this archive
219 // will function correctly with this JVM and the bootclasspath it's
220 // invoked with.
221
222 // JVM version string ... changes on each build.
223 get_header_version(_jvm_ident);
224
225 _app_class_paths_start_index = ClassLoaderExt::app_class_paths_start_index();
226 _app_module_paths_start_index = ClassLoaderExt::app_module_paths_start_index();
227 _max_used_path_index = ClassLoaderExt::max_used_path_index();
228 _num_module_paths = ClassLoader::num_module_path_entries();
229
230 _verify_local = BytecodeVerificationLocal;
231 _verify_remote = BytecodeVerificationRemote;
232 _has_platform_or_app_classes = ClassLoaderExt::has_platform_or_app_classes();
233 _has_non_jar_in_classpath = ClassLoaderExt::has_non_jar_in_classpath();
234 _requested_base_address = (char*)SharedBaseAddress;
235 _mapped_base_address = (char*)SharedBaseAddress;
236 _allow_archiving_with_java_agent = AllowArchivingWithJavaAgent;
237
238 if (!CDSConfig::is_dumping_dynamic_archive()) {
239 set_shared_path_table(info->_shared_path_table);
240 }
241 }
242
243 void FileMapHeader::copy_base_archive_name(const char* archive) {
244 assert(base_archive_name_size() != 0, "_base_archive_name_size not set");
245 assert(base_archive_name_offset() != 0, "_base_archive_name_offset not set");
246 assert(header_size() > sizeof(*this), "_base_archive_name_size not included in header size?");
247 memcpy((char*)this + base_archive_name_offset(), archive, base_archive_name_size());
248 }
249
250 void FileMapHeader::print(outputStream* st) {
251 ResourceMark rm;
252
253 st->print_cr("- magic: 0x%08x", magic());
254 st->print_cr("- crc: 0x%08x", crc());
255 st->print_cr("- version: 0x%x", version());
256 st->print_cr("- header_size: " UINT32_FORMAT, header_size());
275 st->print_cr("- compressed_oops: %d", _compressed_oops);
276 st->print_cr("- compressed_class_ptrs: %d", _compressed_class_ptrs);
277 st->print_cr("- cloned_vtables_offset: " SIZE_FORMAT_X, _cloned_vtables_offset);
278 st->print_cr("- serialized_data_offset: " SIZE_FORMAT_X, _serialized_data_offset);
279 st->print_cr("- jvm_ident: %s", _jvm_ident);
280 st->print_cr("- shared_path_table_offset: " SIZE_FORMAT_X, _shared_path_table_offset);
281 st->print_cr("- app_class_paths_start_index: %d", _app_class_paths_start_index);
282 st->print_cr("- app_module_paths_start_index: %d", _app_module_paths_start_index);
283 st->print_cr("- num_module_paths: %d", _num_module_paths);
284 st->print_cr("- max_used_path_index: %d", _max_used_path_index);
285 st->print_cr("- verify_local: %d", _verify_local);
286 st->print_cr("- verify_remote: %d", _verify_remote);
287 st->print_cr("- has_platform_or_app_classes: %d", _has_platform_or_app_classes);
288 st->print_cr("- has_non_jar_in_classpath: %d", _has_non_jar_in_classpath);
289 st->print_cr("- requested_base_address: " INTPTR_FORMAT, p2i(_requested_base_address));
290 st->print_cr("- mapped_base_address: " INTPTR_FORMAT, p2i(_mapped_base_address));
291 st->print_cr("- heap_roots_offset: " SIZE_FORMAT, _heap_roots_offset);
292 st->print_cr("- allow_archiving_with_java_agent:%d", _allow_archiving_with_java_agent);
293 st->print_cr("- use_optimized_module_handling: %d", _use_optimized_module_handling);
294 st->print_cr("- has_full_module_graph %d", _has_full_module_graph);
295 st->print_cr("- ptrmap_size_in_bits: " SIZE_FORMAT, _ptrmap_size_in_bits);
296 }
297
298 void SharedClassPathEntry::init_as_non_existent(const char* path, TRAPS) {
299 _type = non_existent_entry;
300 set_name(path, CHECK);
301 }
302
303 void SharedClassPathEntry::init(bool is_modules_image,
304 bool is_module_path,
305 ClassPathEntry* cpe, TRAPS) {
306 assert(CDSConfig::is_dumping_archive(), "sanity");
307 _timestamp = 0;
308 _filesize = 0;
309 _from_class_path_attr = false;
310
311 struct stat st;
312 if (os::stat(cpe->name(), &st) == 0) {
313 if ((st.st_mode & S_IFMT) == S_IFDIR) {
314 _type = dir_entry;
315 } else {
1330 if (strncmp(actual_ident, expected_ident, JVM_IDENT_MAX-1) != 0) {
1331 log_info(cds)("_jvm_ident expected: %s", expected_ident);
1332 log_info(cds)(" actual: %s", actual_ident);
1333 log_warning(cds)("The shared archive file was created by a different"
1334 " version or build of HotSpot");
1335 return false;
1336 }
1337
1338 _file_offset = header()->header_size(); // accounts for the size of _base_archive_name
1339
1340 size_t len = os::lseek(fd, 0, SEEK_END);
1341
1342 for (int i = 0; i < MetaspaceShared::n_regions; i++) {
1343 FileMapRegion* r = region_at(i);
1344 if (r->file_offset() > len || len - r->file_offset() < r->used()) {
1345 log_warning(cds)("The shared archive file has been truncated.");
1346 return false;
1347 }
1348 }
1349
1350 return true;
1351 }
1352
1353 void FileMapInfo::seek_to_position(size_t pos) {
1354 if (os::lseek(_fd, (long)pos, SEEK_SET) < 0) {
1355 log_error(cds)("Unable to seek to position " SIZE_FORMAT, pos);
1356 MetaspaceShared::unrecoverable_loading_error();
1357 }
1358 }
1359
1360 // Read the FileMapInfo information from the file.
1361 bool FileMapInfo::open_for_read() {
1362 if (_file_open) {
1363 return true;
1364 }
1365 log_info(cds)("trying to map %s", _full_path);
1366 int fd = os::open(_full_path, O_RDONLY | O_BINARY, 0);
1367 if (fd < 0) {
1368 if (errno == ENOENT) {
1369 log_info(cds)("Specified shared archive not found (%s)", _full_path);
2372 // while AllowArchivingWithJavaAgent is set during the current run.
2373 if (_allow_archiving_with_java_agent && !AllowArchivingWithJavaAgent) {
2374 log_warning(cds)("The setting of the AllowArchivingWithJavaAgent is different "
2375 "from the setting in the shared archive.");
2376 return false;
2377 }
2378
2379 if (_allow_archiving_with_java_agent) {
2380 log_warning(cds)("This archive was created with AllowArchivingWithJavaAgent. It should be used "
2381 "for testing purposes only and should not be used in a production environment");
2382 }
2383
2384 log_info(cds)("Archive was created with UseCompressedOops = %d, UseCompressedClassPointers = %d",
2385 compressed_oops(), compressed_class_pointers());
2386 if (compressed_oops() != UseCompressedOops || compressed_class_pointers() != UseCompressedClassPointers) {
2387 log_info(cds)("Unable to use shared archive.\nThe saved state of UseCompressedOops and UseCompressedClassPointers is "
2388 "different from runtime, CDS will be disabled.");
2389 return false;
2390 }
2391
2392 if (!_use_optimized_module_handling) {
2393 MetaspaceShared::disable_optimized_module_handling();
2394 log_info(cds)("optimized module handling: disabled because archive was created without optimized module handling");
2395 }
2396
2397 if (is_static() && !_has_full_module_graph) {
2398 // Only the static archive can contain the full module graph.
2399 CDSConfig::disable_loading_full_module_graph("archive was created without full module graph");
2400 }
2401
2402 return true;
2403 }
2404
2405 bool FileMapInfo::validate_header() {
2406 if (!header()->validate()) {
2407 return false;
2408 }
2409 if (_is_static) {
2410 return true;
2411 } else {
|
64 #include "runtime/mutexLocker.hpp"
65 #include "runtime/os.hpp"
66 #include "runtime/vm_version.hpp"
67 #include "utilities/align.hpp"
68 #include "utilities/bitMap.inline.hpp"
69 #include "utilities/classpathStream.hpp"
70 #include "utilities/defaultStream.hpp"
71 #include "utilities/ostream.hpp"
72 #if INCLUDE_G1GC
73 #include "gc/g1/g1CollectedHeap.hpp"
74 #include "gc/g1/heapRegion.hpp"
75 #endif
76
77 # include <sys/stat.h>
78 # include <errno.h>
79
80 #ifndef O_BINARY // if defined (Win32) use binary files.
81 #define O_BINARY 0 // otherwise do nothing.
82 #endif
83
84 inline void CDSMustMatchFlags::do_print(outputStream* st, bool v) {
85 st->print("%s", v ? "true" : "false");
86 }
87
88 inline void CDSMustMatchFlags::do_print(outputStream* st, intx v) {
89 st->print(INTX_FORMAT, v);
90 }
91
92 inline void CDSMustMatchFlags::do_print(outputStream* st, uintx v) {
93 st->print(UINTX_FORMAT, v);
94 }
95
96 inline void CDSMustMatchFlags::do_print(outputStream* st, double v) {
97 st->print("%f", v);
98 }
99
100 void CDSMustMatchFlags::init() {
101 assert(CDSConfig::is_dumping_archive(), "sanity");
102 _max_name_width = 0;
103
104 #define INIT_CDS_MUST_MATCH_FLAG(n) \
105 _v_##n = n; \
106 _max_name_width = MAX2(_max_name_width,strlen(#n));
107 CDS_MUST_MATCH_FLAGS_DO(INIT_CDS_MUST_MATCH_FLAG);
108 #undef INIT_CDS_MUST_MATCH_FLAG
109 }
110
111 bool CDSMustMatchFlags::runtime_check() const {
112 #define CHECK_CDS_MUST_MATCH_FLAG(n) \
113 if (_v_##n != n) { \
114 ResourceMark rm; \
115 stringStream ss; \
116 ss.print("VM option %s is different between dumptime (", #n); \
117 do_print(&ss, _v_ ## n); \
118 ss.print(") and runtime ("); \
119 do_print(&ss, n); \
120 ss.print(")"); \
121 log_info(cds)("%s", ss.as_string()); \
122 return false; \
123 }
124 CDS_MUST_MATCH_FLAGS_DO(CHECK_CDS_MUST_MATCH_FLAG);
125 #undef CHECK_CDS_MUST_MATCH_FLAG
126
127 return true;
128 }
129
130 void CDSMustMatchFlags::print_info() const {
131 LogTarget(Info, cds) lt;
132 if (lt.is_enabled()) {
133 LogStream ls(lt);
134 ls.print_cr("Recorded VM flags during dumptime:");
135 print(&ls);
136 }
137 }
138
139 void CDSMustMatchFlags::print(outputStream* st) const {
140 #define PRINT_CDS_MUST_MATCH_FLAG(n) \
141 st->print("- %-s ", #n); \
142 st->sp(int(_max_name_width - strlen(#n))); \
143 do_print(st, _v_##n); \
144 st->cr();
145 CDS_MUST_MATCH_FLAGS_DO(PRINT_CDS_MUST_MATCH_FLAG);
146 #undef PRINT_CDS_MUST_MATCH_FLAG
147 }
148
149 // Fill in the fileMapInfo structure with data about this VM instance.
150
151 // This method copies the vm version info into header_version. If the version is too
152 // long then a truncated version, which has a hash code appended to it, is copied.
153 //
154 // Using a template enables this method to verify that header_version is an array of
155 // length JVM_IDENT_MAX. This ensures that the code that writes to the CDS file and
156 // the code that reads the CDS file will both use the same size buffer. Hence, will
157 // use identical truncation. This is necessary for matching of truncated versions.
158 template <int N> static void get_header_version(char (&header_version) [N]) {
159 assert(N == JVM_IDENT_MAX, "Bad header_version size");
160
161 const char *vm_version = VM_Version::internal_vm_info_string();
162 const int version_len = (int)strlen(vm_version);
163
164 memset(header_version, 0, JVM_IDENT_MAX);
165
166 if (version_len < (JVM_IDENT_MAX-1)) {
167 strcpy(header_version, vm_version);
168
262 set_magic(CDSConfig::is_dumping_dynamic_archive() ? CDS_DYNAMIC_ARCHIVE_MAGIC : CDS_ARCHIVE_MAGIC);
263 set_version(CURRENT_CDS_ARCHIVE_VERSION);
264
265 if (!info->is_static() && base_archive_name_size != 0) {
266 // copy base archive name
267 copy_base_archive_name(CDSConfig::static_archive_path());
268 }
269 _core_region_alignment = core_region_alignment;
270 _obj_alignment = ObjectAlignmentInBytes;
271 _compact_strings = CompactStrings;
272 if (CDSConfig::is_dumping_heap()) {
273 _narrow_oop_mode = CompressedOops::mode();
274 _narrow_oop_base = CompressedOops::base();
275 _narrow_oop_shift = CompressedOops::shift();
276 }
277 _compressed_oops = UseCompressedOops;
278 _compressed_class_ptrs = UseCompressedClassPointers;
279 _max_heap_size = MaxHeapSize;
280 _use_optimized_module_handling = MetaspaceShared::use_optimized_module_handling();
281 _has_full_module_graph = CDSConfig::is_dumping_full_module_graph();
282 _has_valhalla_patched_classes = CDSConfig::is_valhalla_preview();
283 // The following fields are for sanity checks for whether this archive
284 // will function correctly with this JVM and the bootclasspath it's
285 // invoked with.
286
287 // JVM version string ... changes on each build.
288 get_header_version(_jvm_ident);
289
290 _app_class_paths_start_index = ClassLoaderExt::app_class_paths_start_index();
291 _app_module_paths_start_index = ClassLoaderExt::app_module_paths_start_index();
292 _max_used_path_index = ClassLoaderExt::max_used_path_index();
293 _num_module_paths = ClassLoader::num_module_path_entries();
294
295 _verify_local = BytecodeVerificationLocal;
296 _verify_remote = BytecodeVerificationRemote;
297 _has_platform_or_app_classes = ClassLoaderExt::has_platform_or_app_classes();
298 _has_non_jar_in_classpath = ClassLoaderExt::has_non_jar_in_classpath();
299 _requested_base_address = (char*)SharedBaseAddress;
300 _mapped_base_address = (char*)SharedBaseAddress;
301 _allow_archiving_with_java_agent = AllowArchivingWithJavaAgent;
302 _must_match.init();
303
304 if (!CDSConfig::is_dumping_dynamic_archive()) {
305 set_shared_path_table(info->_shared_path_table);
306 }
307 }
308
309 void FileMapHeader::copy_base_archive_name(const char* archive) {
310 assert(base_archive_name_size() != 0, "_base_archive_name_size not set");
311 assert(base_archive_name_offset() != 0, "_base_archive_name_offset not set");
312 assert(header_size() > sizeof(*this), "_base_archive_name_size not included in header size?");
313 memcpy((char*)this + base_archive_name_offset(), archive, base_archive_name_size());
314 }
315
316 void FileMapHeader::print(outputStream* st) {
317 ResourceMark rm;
318
319 st->print_cr("- magic: 0x%08x", magic());
320 st->print_cr("- crc: 0x%08x", crc());
321 st->print_cr("- version: 0x%x", version());
322 st->print_cr("- header_size: " UINT32_FORMAT, header_size());
341 st->print_cr("- compressed_oops: %d", _compressed_oops);
342 st->print_cr("- compressed_class_ptrs: %d", _compressed_class_ptrs);
343 st->print_cr("- cloned_vtables_offset: " SIZE_FORMAT_X, _cloned_vtables_offset);
344 st->print_cr("- serialized_data_offset: " SIZE_FORMAT_X, _serialized_data_offset);
345 st->print_cr("- jvm_ident: %s", _jvm_ident);
346 st->print_cr("- shared_path_table_offset: " SIZE_FORMAT_X, _shared_path_table_offset);
347 st->print_cr("- app_class_paths_start_index: %d", _app_class_paths_start_index);
348 st->print_cr("- app_module_paths_start_index: %d", _app_module_paths_start_index);
349 st->print_cr("- num_module_paths: %d", _num_module_paths);
350 st->print_cr("- max_used_path_index: %d", _max_used_path_index);
351 st->print_cr("- verify_local: %d", _verify_local);
352 st->print_cr("- verify_remote: %d", _verify_remote);
353 st->print_cr("- has_platform_or_app_classes: %d", _has_platform_or_app_classes);
354 st->print_cr("- has_non_jar_in_classpath: %d", _has_non_jar_in_classpath);
355 st->print_cr("- requested_base_address: " INTPTR_FORMAT, p2i(_requested_base_address));
356 st->print_cr("- mapped_base_address: " INTPTR_FORMAT, p2i(_mapped_base_address));
357 st->print_cr("- heap_roots_offset: " SIZE_FORMAT, _heap_roots_offset);
358 st->print_cr("- allow_archiving_with_java_agent:%d", _allow_archiving_with_java_agent);
359 st->print_cr("- use_optimized_module_handling: %d", _use_optimized_module_handling);
360 st->print_cr("- has_full_module_graph %d", _has_full_module_graph);
361 st->print_cr("- has_valhalla_patched_classes %d", _has_valhalla_patched_classes);
362 st->print_cr("- ptrmap_size_in_bits: " SIZE_FORMAT, _ptrmap_size_in_bits);
363 _must_match.print(st);
364 }
365
366 void SharedClassPathEntry::init_as_non_existent(const char* path, TRAPS) {
367 _type = non_existent_entry;
368 set_name(path, CHECK);
369 }
370
371 void SharedClassPathEntry::init(bool is_modules_image,
372 bool is_module_path,
373 ClassPathEntry* cpe, TRAPS) {
374 assert(CDSConfig::is_dumping_archive(), "sanity");
375 _timestamp = 0;
376 _filesize = 0;
377 _from_class_path_attr = false;
378
379 struct stat st;
380 if (os::stat(cpe->name(), &st) == 0) {
381 if ((st.st_mode & S_IFMT) == S_IFDIR) {
382 _type = dir_entry;
383 } else {
1398 if (strncmp(actual_ident, expected_ident, JVM_IDENT_MAX-1) != 0) {
1399 log_info(cds)("_jvm_ident expected: %s", expected_ident);
1400 log_info(cds)(" actual: %s", actual_ident);
1401 log_warning(cds)("The shared archive file was created by a different"
1402 " version or build of HotSpot");
1403 return false;
1404 }
1405
1406 _file_offset = header()->header_size(); // accounts for the size of _base_archive_name
1407
1408 size_t len = os::lseek(fd, 0, SEEK_END);
1409
1410 for (int i = 0; i < MetaspaceShared::n_regions; i++) {
1411 FileMapRegion* r = region_at(i);
1412 if (r->file_offset() > len || len - r->file_offset() < r->used()) {
1413 log_warning(cds)("The shared archive file has been truncated.");
1414 return false;
1415 }
1416 }
1417
1418 if (!header()->check_must_match_flags()) {
1419 return false;
1420 }
1421
1422 return true;
1423 }
1424
1425 void FileMapInfo::seek_to_position(size_t pos) {
1426 if (os::lseek(_fd, (long)pos, SEEK_SET) < 0) {
1427 log_error(cds)("Unable to seek to position " SIZE_FORMAT, pos);
1428 MetaspaceShared::unrecoverable_loading_error();
1429 }
1430 }
1431
1432 // Read the FileMapInfo information from the file.
1433 bool FileMapInfo::open_for_read() {
1434 if (_file_open) {
1435 return true;
1436 }
1437 log_info(cds)("trying to map %s", _full_path);
1438 int fd = os::open(_full_path, O_RDONLY | O_BINARY, 0);
1439 if (fd < 0) {
1440 if (errno == ENOENT) {
1441 log_info(cds)("Specified shared archive not found (%s)", _full_path);
2444 // while AllowArchivingWithJavaAgent is set during the current run.
2445 if (_allow_archiving_with_java_agent && !AllowArchivingWithJavaAgent) {
2446 log_warning(cds)("The setting of the AllowArchivingWithJavaAgent is different "
2447 "from the setting in the shared archive.");
2448 return false;
2449 }
2450
2451 if (_allow_archiving_with_java_agent) {
2452 log_warning(cds)("This archive was created with AllowArchivingWithJavaAgent. It should be used "
2453 "for testing purposes only and should not be used in a production environment");
2454 }
2455
2456 log_info(cds)("Archive was created with UseCompressedOops = %d, UseCompressedClassPointers = %d",
2457 compressed_oops(), compressed_class_pointers());
2458 if (compressed_oops() != UseCompressedOops || compressed_class_pointers() != UseCompressedClassPointers) {
2459 log_info(cds)("Unable to use shared archive.\nThe saved state of UseCompressedOops and UseCompressedClassPointers is "
2460 "different from runtime, CDS will be disabled.");
2461 return false;
2462 }
2463
2464 if (is_static()) {
2465 const char* err = nullptr;
2466 if (CDSConfig::is_valhalla_preview()) {
2467 if (!_has_valhalla_patched_classes) {
2468 err = "not created";
2469 }
2470 } else {
2471 if (_has_valhalla_patched_classes) {
2472 err = "created";
2473 }
2474 }
2475 if (err != nullptr) {
2476 log_warning(cds)("This archive was %s with --enable-preview -XX:+EnableValhalla. It is "
2477 "incompatible with the current JVM setting", err);
2478 return false;
2479 }
2480 }
2481
2482 if (!_use_optimized_module_handling) {
2483 MetaspaceShared::disable_optimized_module_handling();
2484 log_info(cds)("optimized module handling: disabled because archive was created without optimized module handling");
2485 }
2486
2487 if (is_static() && !_has_full_module_graph) {
2488 // Only the static archive can contain the full module graph.
2489 CDSConfig::disable_loading_full_module_graph("archive was created without full module graph");
2490 }
2491
2492 return true;
2493 }
2494
2495 bool FileMapInfo::validate_header() {
2496 if (!header()->validate()) {
2497 return false;
2498 }
2499 if (_is_static) {
2500 return true;
2501 } else {
|