truffle: src/share/vm/memory/universe.cpp annotate

annotate src/share/vm/memory/universe.cpp @ 12233:40136aa2cdb1

8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes

author	tschatzl
date	Wed, 11 Sep 2013 16:25:02 +0200
parents	7944aba7ba41
children	23ae5a04724d

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7623 203f64878aab 7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems. hseigel parents: 7187 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	26 #include "classfile/classLoader.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	27 #include "classfile/classLoaderData.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	28 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	29 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	30 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	31 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	32 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	33 #include "code/dependencies.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	34 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	35 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	36 #include "memory/cardTableModRefBS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	37 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	38 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	39 #include "memory/genRemSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	40 #include "memory/generation.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	41 #include "memory/metadataFactory.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	42 #include "memory/metaspaceShared.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	43 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	44 #include "memory/space.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	45 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	46 #include "memory/universe.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	47 #include "oops/constantPool.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	48 #include "oops/instanceClassLoaderKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	49 #include "oops/instanceKlass.hpp"
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2375 diff changeset	50 #include "oops/instanceMirrorKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	51 #include "oops/instanceRefKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	52 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	53 #include "oops/typeArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	54 #include "prims/jvmtiRedefineClassesTrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	55 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	56 #include "runtime/deoptimization.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	57 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	58 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	59 #include "runtime/init.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	60 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	61 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	62 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	63 #include "runtime/synchronizer.hpp"
7180 f34d701e952e 8003935: Simplify the needed includes for using Thread::current() stefank parents: 6985 diff changeset	64 #include "runtime/thread.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	65 #include "runtime/timer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	66 #include "runtime/vm_operations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	67 #include "services/memoryService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	68 #include "utilities/copy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	69 #include "utilities/events.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	70 #include "utilities/hashtable.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	71 #include "utilities/preserveException.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	72 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	73 #if INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	74 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	75 #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	76 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	77 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1966 diff changeset	78 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	79 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 // Known objects
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	82 Klass* Universe::_boolArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	83 Klass* Universe::_byteArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	84 Klass* Universe::_charArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	85 Klass* Universe::_intArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	86 Klass* Universe::_shortArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	87 Klass* Universe::_longArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	88 Klass* Universe::_singleArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	89 Klass* Universe::_doubleArrayKlassObj = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	90 Klass* Universe::_typeArrayKlassObjs[T_VOID+1] = { NULL /, NULL.../ };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	91 Klass* Universe::_objectArrayKlassObj = NULL;
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	92 oop Universe::_int_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	93 oop Universe::_float_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	94 oop Universe::_double_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	95 oop Universe::_byte_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	96 oop Universe::_bool_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	97 oop Universe::_char_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	98 oop Universe::_long_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	99 oop Universe::_short_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	100 oop Universe::_void_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	101 oop Universe::_mirrors[T_VOID+1] = { NULL /, NULL.../ };
0 a61af66fc99e Initial load duke parents: diff changeset	102 oop Universe::_main_thread_group = NULL;
a61af66fc99e Initial load duke parents: diff changeset	103 oop Universe::_system_thread_group = NULL;
a61af66fc99e Initial load duke parents: diff changeset	104 objArrayOop Universe::_the_empty_class_klass_array = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	105 Array<Klass> Universe::_the_array_interfaces_array = NULL;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	106 oop Universe::_the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	107 oop Universe::_the_min_jint_string = NULL;
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	108 LatestMethodCache* Universe::_finalizer_register_cache = NULL;
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	109 LatestMethodCache* Universe::_loader_addClass_cache = NULL;
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	110 LatestMethodCache* Universe::_pd_implies_cache = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	111 oop Universe::_out_of_memory_error_java_heap = NULL;
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	112 oop Universe::_out_of_memory_error_metaspace = NULL;
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	113 oop Universe::_out_of_memory_error_class_metaspace = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	114 oop Universe::_out_of_memory_error_array_size = NULL;
a61af66fc99e Initial load duke parents: diff changeset	115 oop Universe::_out_of_memory_error_gc_overhead_limit = NULL;
a61af66fc99e Initial load duke parents: diff changeset	116 objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	117 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	118 bool Universe::_verify_in_progress = false;
a61af66fc99e Initial load duke parents: diff changeset	119 oop Universe::_null_ptr_exception_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	120 oop Universe::_arithmetic_exception_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	121 oop Universe::_virtual_machine_error_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	122 oop Universe::_vm_exception = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	123 Array<int>* Universe::_the_empty_int_array = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	124 Array<u2>* Universe::_the_empty_short_array = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	125 Array<Klass> Universe::_the_empty_klass_array = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	126 Array<Method> Universe::_the_empty_method_array = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 // These variables are guarded by FullGCALot_lock.
a61af66fc99e Initial load duke parents: diff changeset	129 debug_only(objArrayOop Universe::_fullgc_alot_dummy_array = NULL;)
a61af66fc99e Initial load duke parents: diff changeset	130 debug_only(int Universe::_fullgc_alot_dummy_next = 0;)
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 // Heap
a61af66fc99e Initial load duke parents: diff changeset	133 int Universe::_verify_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135 int Universe::_base_vtable_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	136 bool Universe::_bootstrapping = false;
a61af66fc99e Initial load duke parents: diff changeset	137 bool Universe::_fully_initialized = false;
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139 size_t Universe::_heap_capacity_at_last_gc;
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	140 size_t Universe::_heap_used_at_last_gc = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 CollectedHeap* Universe::_collectedHeap = NULL;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	143
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	144 NarrowPtrStruct Universe::_narrow_oop = { NULL, 0, true };
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	145 NarrowPtrStruct Universe::_narrow_klass = { NULL, 0, true };
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	146 address Universe::_narrow_ptrs_base;
0 a61af66fc99e Initial load duke parents: diff changeset	147
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	148 void Universe::basic_type_classes_do(void f(Klass*)) {
0 a61af66fc99e Initial load duke parents: diff changeset	149 f(boolArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	150 f(byteArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	151 f(charArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	152 f(intArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	153 f(shortArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	154 f(longArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	155 f(singleArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	156 f(doubleArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	157 }
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 void Universe::oops_do(OopClosure* f, bool do_all) {
a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 f->do_oop((oop*) &_int_mirror);
a61af66fc99e Initial load duke parents: diff changeset	162 f->do_oop((oop*) &_float_mirror);
a61af66fc99e Initial load duke parents: diff changeset	163 f->do_oop((oop*) &_double_mirror);
a61af66fc99e Initial load duke parents: diff changeset	164 f->do_oop((oop*) &_byte_mirror);
a61af66fc99e Initial load duke parents: diff changeset	165 f->do_oop((oop*) &_bool_mirror);
a61af66fc99e Initial load duke parents: diff changeset	166 f->do_oop((oop*) &_char_mirror);
a61af66fc99e Initial load duke parents: diff changeset	167 f->do_oop((oop*) &_long_mirror);
a61af66fc99e Initial load duke parents: diff changeset	168 f->do_oop((oop*) &_short_mirror);
a61af66fc99e Initial load duke parents: diff changeset	169 f->do_oop((oop*) &_void_mirror);
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
a61af66fc99e Initial load duke parents: diff changeset	172 f->do_oop((oop*) &_mirrors[i]);
a61af66fc99e Initial load duke parents: diff changeset	173 }
a61af66fc99e Initial load duke parents: diff changeset	174 assert(_mirrors[0] == NULL && _mirrors[T_BOOLEAN - 1] == NULL, "checking");
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 f->do_oop((oop*)&_the_empty_class_klass_array);
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	177 f->do_oop((oop*)&_the_null_string);
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	178 f->do_oop((oop*)&_the_min_jint_string);
0 a61af66fc99e Initial load duke parents: diff changeset	179 f->do_oop((oop*)&_out_of_memory_error_java_heap);
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	180 f->do_oop((oop*)&_out_of_memory_error_metaspace);
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	181 f->do_oop((oop*)&_out_of_memory_error_class_metaspace);
0 a61af66fc99e Initial load duke parents: diff changeset	182 f->do_oop((oop*)&_out_of_memory_error_array_size);
a61af66fc99e Initial load duke parents: diff changeset	183 f->do_oop((oop*)&_out_of_memory_error_gc_overhead_limit);
a61af66fc99e Initial load duke parents: diff changeset	184 f->do_oop((oop*)&_preallocated_out_of_memory_error_array);
a61af66fc99e Initial load duke parents: diff changeset	185 f->do_oop((oop*)&_null_ptr_exception_instance);
a61af66fc99e Initial load duke parents: diff changeset	186 f->do_oop((oop*)&_arithmetic_exception_instance);
a61af66fc99e Initial load duke parents: diff changeset	187 f->do_oop((oop*)&_virtual_machine_error_instance);
a61af66fc99e Initial load duke parents: diff changeset	188 f->do_oop((oop*)&_main_thread_group);
a61af66fc99e Initial load duke parents: diff changeset	189 f->do_oop((oop*)&_system_thread_group);
a61af66fc99e Initial load duke parents: diff changeset	190 f->do_oop((oop*)&_vm_exception);
a61af66fc99e Initial load duke parents: diff changeset	191 debug_only(f->do_oop((oop*)&_fullgc_alot_dummy_array);)
a61af66fc99e Initial load duke parents: diff changeset	192 }
a61af66fc99e Initial load duke parents: diff changeset	193
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	194 // Serialize metadata in and out of CDS archive, not oops.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	195 void Universe::serialize(SerializeClosure* f, bool do_all) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	196
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	197 f->do_ptr((void**)&_boolArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	198 f->do_ptr((void**)&_byteArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	199 f->do_ptr((void**)&_charArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	200 f->do_ptr((void**)&_intArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	201 f->do_ptr((void**)&_shortArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	202 f->do_ptr((void**)&_longArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	203 f->do_ptr((void**)&_singleArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	204 f->do_ptr((void**)&_doubleArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	205 f->do_ptr((void**)&_objectArrayKlassObj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	206
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	207 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	208 for (int i = 0; i < T_VOID+1; i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	209 if (_typeArrayKlassObjs[i] != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	210 assert(i >= T_BOOLEAN, "checking");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	211 f->do_ptr((void**)&_typeArrayKlassObjs[i]);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	212 } else if (do_all) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	213 f->do_ptr((void**)&_typeArrayKlassObjs[i]);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	214 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	215 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	216 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	217
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	218 f->do_ptr((void**)&_the_array_interfaces_array);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	219 f->do_ptr((void**)&_the_empty_int_array);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	220 f->do_ptr((void**)&_the_empty_short_array);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	221 f->do_ptr((void**)&_the_empty_method_array);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	222 f->do_ptr((void**)&_the_empty_klass_array);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	223 _finalizer_register_cache->serialize(f);
6751 2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	224 _loader_addClass_cache->serialize(f);
11010 b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	225 _pd_implies_cache->serialize(f);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	226 }
0 a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 void Universe::check_alignment(uintx size, uintx alignment, const char* name) {
a61af66fc99e Initial load duke parents: diff changeset	229 if (size < alignment \|\| size % alignment != 0) {
10358 0def34ab1c98 8015007: Incorrect print format in error message for VM cannot allocate the requested heap tamao parents: 10265 diff changeset	230 vm_exit_during_initialization(
0def34ab1c98 8015007: Incorrect print format in error message for VM cannot allocate the requested heap tamao parents: 10265 diff changeset	231 err_msg("Size of %s (" UINTX_FORMAT " bytes) must be aligned to " UINTX_FORMAT " bytes", name, size, alignment));
0 a61af66fc99e Initial load duke parents: diff changeset	232 }
a61af66fc99e Initial load duke parents: diff changeset	233 }
a61af66fc99e Initial load duke parents: diff changeset	234
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	235 void initialize_basic_type_klass(Klass* k, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	236 Klass* ok = SystemDictionary::Object_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	237 if (UseSharedSpaces) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	238 assert(k->super() == ok, "u3");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	239 k->restore_unshareable_info(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	240 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	241 k->initialize_supers(ok, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	242 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	243 k->append_to_sibling_list();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	244 }
0 a61af66fc99e Initial load duke parents: diff changeset	245
a61af66fc99e Initial load duke parents: diff changeset	246 void Universe::genesis(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	247 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	248
0 a61af66fc99e Initial load duke parents: diff changeset	249 { FlagSetting fs(_bootstrapping, true);
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 { MutexLocker mc(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253 // determine base vtable size; without that we cannot create the array klasses
a61af66fc99e Initial load duke parents: diff changeset	254 compute_base_vtable_size();
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 if (!UseSharedSpaces) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	257 _boolArrayKlassObj = TypeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	258 _charArrayKlassObj = TypeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	259 _singleArrayKlassObj = TypeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	260 _doubleArrayKlassObj = TypeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	261 _byteArrayKlassObj = TypeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	262 _shortArrayKlassObj = TypeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	263 _intArrayKlassObj = TypeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	264 _longArrayKlassObj = TypeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	267 _typeArrayKlassObjs[T_CHAR] = _charArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	268 _typeArrayKlassObjs[T_FLOAT] = _singleArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	269 _typeArrayKlassObjs[T_DOUBLE] = _doubleArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	270 _typeArrayKlassObjs[T_BYTE] = _byteArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	271 _typeArrayKlassObjs[T_SHORT] = _shortArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	272 _typeArrayKlassObjs[T_INT] = _intArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	273 _typeArrayKlassObjs[T_LONG] = _longArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	274
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	275 ClassLoaderData* null_cld = ClassLoaderData::the_null_class_loader_data();
0 a61af66fc99e Initial load duke parents: diff changeset	276
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	277 _the_array_interfaces_array = MetadataFactory::new_array<Klass*>(null_cld, 2, NULL, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	278 _the_empty_int_array = MetadataFactory::new_array<int>(null_cld, 0, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	279 _the_empty_short_array = MetadataFactory::new_array<u2>(null_cld, 0, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	280 _the_empty_method_array = MetadataFactory::new_array<Method*>(null_cld, 0, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	281 _the_empty_klass_array = MetadataFactory::new_array<Klass*>(null_cld, 0, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	282 }
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 vmSymbols::initialize(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 SystemDictionary::initialize(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	288
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	289 Klass* ok = SystemDictionary::Object_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	290
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	291 _the_null_string = StringTable::intern("null", CHECK);
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	292 _the_min_jint_string = StringTable::intern("-2147483648", CHECK);
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	293
0 a61af66fc99e Initial load duke parents: diff changeset	294 if (UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	295 // Verify shared interfaces array.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	296 assert(_the_array_interfaces_array->at(0) ==
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	297 SystemDictionary::Cloneable_klass(), "u3");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	298 assert(_the_array_interfaces_array->at(1) ==
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	299 SystemDictionary::Serializable_klass(), "u3");
0 a61af66fc99e Initial load duke parents: diff changeset	300 } else {
a61af66fc99e Initial load duke parents: diff changeset	301 // Set up shared interfaces array. (Do this before supers are set up.)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	302 _the_array_interfaces_array->at_put(0, SystemDictionary::Cloneable_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	303 _the_array_interfaces_array->at_put(1, SystemDictionary::Serializable_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	304 }
a61af66fc99e Initial load duke parents: diff changeset	305
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	306 initialize_basic_type_klass(boolArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	307 initialize_basic_type_klass(charArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	308 initialize_basic_type_klass(singleArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	309 initialize_basic_type_klass(doubleArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	310 initialize_basic_type_klass(byteArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	311 initialize_basic_type_klass(shortArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	312 initialize_basic_type_klass(intArrayKlassObj(), CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	313 initialize_basic_type_klass(longArrayKlassObj(), CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	314 } // end of core bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	315
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	316 // Maybe this could be lifted up now that object array can be initialized
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	317 // during the bootstrapping.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	318
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	319 // OLD
0 a61af66fc99e Initial load duke parents: diff changeset	320 // Initialize _objectArrayKlass after core bootstraping to make
a61af66fc99e Initial load duke parents: diff changeset	321 // sure the super class is set up properly for _objectArrayKlass.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	322 // ---
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	323 // NEW
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	324 // Since some of the old system object arrays have been converted to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	325 // ordinary object arrays, _objectArrayKlass will be loaded when
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	326 // SystemDictionary::initialize(CHECK); is run. See the extra check
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	327 // for Object_klass_loaded in objArrayKlassKlass::allocate_objArray_klass_impl.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	328 _objectArrayKlassObj = InstanceKlass::
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	329 cast(SystemDictionary::Object_klass())->array_klass(1, CHECK);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	330 // OLD
0 a61af66fc99e Initial load duke parents: diff changeset	331 // Add the class to the class hierarchy manually to make sure that
a61af66fc99e Initial load duke parents: diff changeset	332 // its vtable is initialized after core bootstrapping is completed.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	333 // ---
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	334 // New
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	335 // Have already been initialized.
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6870 diff changeset	336 _objectArrayKlassObj->append_to_sibling_list();
0 a61af66fc99e Initial load duke parents: diff changeset	337
a61af66fc99e Initial load duke parents: diff changeset	338 // Compute is_jdk version flags.
a61af66fc99e Initial load duke parents: diff changeset	339 // Only 1.3 or later has the java.lang.Shutdown class.
a61af66fc99e Initial load duke parents: diff changeset	340 // Only 1.4 or later has the java.lang.CharSequence interface.
a61af66fc99e Initial load duke parents: diff changeset	341 // Only 1.5 or later has the java.lang.management.MemoryUsage class.
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	342 if (JDK_Version::is_partially_initialized()) {
d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	343 uint8_t jdk_version;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	344 Klass* k = SystemDictionary::resolve_or_null(
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	345 vmSymbols::java_lang_management_MemoryUsage(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	346 CLEAR_PENDING_EXCEPTION; // ignore exceptions
a61af66fc99e Initial load duke parents: diff changeset	347 if (k == NULL) {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	348 k = SystemDictionary::resolve_or_null(
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	349 vmSymbols::java_lang_CharSequence(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	350 CLEAR_PENDING_EXCEPTION; // ignore exceptions
a61af66fc99e Initial load duke parents: diff changeset	351 if (k == NULL) {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	352 k = SystemDictionary::resolve_or_null(
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	353 vmSymbols::java_lang_Shutdown(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	354 CLEAR_PENDING_EXCEPTION; // ignore exceptions
a61af66fc99e Initial load duke parents: diff changeset	355 if (k == NULL) {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	356 jdk_version = 2;
0 a61af66fc99e Initial load duke parents: diff changeset	357 } else {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	358 jdk_version = 3;
0 a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 } else {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	361 jdk_version = 4;
0 a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363 } else {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	364 jdk_version = 5;
0 a61af66fc99e Initial load duke parents: diff changeset	365 }
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	366 JDK_Version::fully_initialize(jdk_version);
0 a61af66fc99e Initial load duke parents: diff changeset	367 }
a61af66fc99e Initial load duke parents: diff changeset	368
a61af66fc99e Initial load duke parents: diff changeset	369 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	370 if (FullGCALot) {
a61af66fc99e Initial load duke parents: diff changeset	371 // Allocate an array of dummy objects.
a61af66fc99e Initial load duke parents: diff changeset	372 // We'd like these to be at the bottom of the old generation,
a61af66fc99e Initial load duke parents: diff changeset	373 // so that when we free one and then collect,
a61af66fc99e Initial load duke parents: diff changeset	374 // (almost) the whole heap moves
a61af66fc99e Initial load duke parents: diff changeset	375 // and we find out if we actually update all the oops correctly.
a61af66fc99e Initial load duke parents: diff changeset	376 // But we can't allocate directly in the old generation,
a61af66fc99e Initial load duke parents: diff changeset	377 // so we allocate wherever, and hope that the first collection
a61af66fc99e Initial load duke parents: diff changeset	378 // moves these objects to the bottom of the old generation.
a61af66fc99e Initial load duke parents: diff changeset	379 // We can allocate directly in the permanent generation, so we do.
a61af66fc99e Initial load duke parents: diff changeset	380 int size;
a61af66fc99e Initial load duke parents: diff changeset	381 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	382 warning("Using +FullGCALot with concurrent mark sweep gc "
a61af66fc99e Initial load duke parents: diff changeset	383 "will not force all objects to relocate");
a61af66fc99e Initial load duke parents: diff changeset	384 size = FullGCALotDummies;
a61af66fc99e Initial load duke parents: diff changeset	385 } else {
a61af66fc99e Initial load duke parents: diff changeset	386 size = FullGCALotDummies * 2;
a61af66fc99e Initial load duke parents: diff changeset	387 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	388 objArrayOop naked_array = oopFactory::new_objArray(SystemDictionary::Object_klass(), size, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	389 objArrayHandle dummy_array(THREAD, naked_array);
a61af66fc99e Initial load duke parents: diff changeset	390 int i = 0;
a61af66fc99e Initial load duke parents: diff changeset	391 while (i < size) {
a61af66fc99e Initial load duke parents: diff changeset	392 // Allocate dummy in old generation
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	393 oop dummy = InstanceKlass::cast(SystemDictionary::Object_klass())->allocate_instance(CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	394 dummy_array->obj_at_put(i++, dummy);
a61af66fc99e Initial load duke parents: diff changeset	395 }
a61af66fc99e Initial load duke parents: diff changeset	396 {
a61af66fc99e Initial load duke parents: diff changeset	397 // Only modify the global variable inside the mutex.
a61af66fc99e Initial load duke parents: diff changeset	398 // If we had a race to here, the other dummy_array instances
a61af66fc99e Initial load duke parents: diff changeset	399 // and their elements just get dropped on the floor, which is fine.
a61af66fc99e Initial load duke parents: diff changeset	400 MutexLocker ml(FullGCALot_lock);
a61af66fc99e Initial load duke parents: diff changeset	401 if (_fullgc_alot_dummy_array == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	402 _fullgc_alot_dummy_array = dummy_array();
a61af66fc99e Initial load duke parents: diff changeset	403 }
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405 assert(i == _fullgc_alot_dummy_array->length(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	406 }
a61af66fc99e Initial load duke parents: diff changeset	407 #endif
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 7180 diff changeset	408
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 7180 diff changeset	409 // Initialize dependency array for null class loader
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 7180 diff changeset	410 ClassLoaderData::the_null_class_loader_data()->init_dependencies(CHECK);
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 7180 diff changeset	411
0 a61af66fc99e Initial load duke parents: diff changeset	412 }
a61af66fc99e Initial load duke parents: diff changeset	413
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	414 // CDS support for patching vtables in metadata in the shared archive.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	415 // All types inherited from Metadata have vtables, but not types inherited
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	416 // from MetaspaceObj, because the latter does not have virtual functions.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	417 // If the metadata type has a vtable, it cannot be shared in the read-only
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	418 // section of the CDS archive, because the vtable pointer is patched.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	419 static inline void add_vtable(void** list, int* n, void* o, int count) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	420 guarantee((*n) < count, "vtable list too small");
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6985 diff changeset	421 void* vtable = dereference_vptr(o);
59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6985 diff changeset	422 assert((void*)(vtable) != NULL, "invalid vtable");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	423 list[(*n)++] = vtable;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	424 }
0 a61af66fc99e Initial load duke parents: diff changeset	425
a61af66fc99e Initial load duke parents: diff changeset	426 void Universe::init_self_patching_vtbl_list(void** list, int count) {
a61af66fc99e Initial load duke parents: diff changeset	427 int n = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	428 { InstanceKlass o; add_vtable(list, &n, &o, count); }
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	429 { InstanceClassLoaderKlass o; add_vtable(list, &n, &o, count); }
aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	430 { InstanceMirrorKlass o; add_vtable(list, &n, &o, count); }
aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	431 { InstanceRefKlass o; add_vtable(list, &n, &o, count); }
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	432 { TypeArrayKlass o; add_vtable(list, &n, &o, count); }
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6751 diff changeset	433 { ObjArrayKlass o; add_vtable(list, &n, &o, count); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	434 { Method o; add_vtable(list, &n, &o, count); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	435 { ConstantPool o; add_vtable(list, &n, &o, count); }
0 a61af66fc99e Initial load duke parents: diff changeset	436 }
a61af66fc99e Initial load duke parents: diff changeset	437
a61af66fc99e Initial load duke parents: diff changeset	438 void Universe::initialize_basic_type_mirrors(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	439 assert(_int_mirror==NULL, "basic type mirrors already initialized");
a61af66fc99e Initial load duke parents: diff changeset	440 _int_mirror =
a61af66fc99e Initial load duke parents: diff changeset	441 java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	442 _float_mirror =
a61af66fc99e Initial load duke parents: diff changeset	443 java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	444 _double_mirror =
a61af66fc99e Initial load duke parents: diff changeset	445 java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	446 _byte_mirror =
a61af66fc99e Initial load duke parents: diff changeset	447 java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	448 _bool_mirror =
a61af66fc99e Initial load duke parents: diff changeset	449 java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	450 _char_mirror =
a61af66fc99e Initial load duke parents: diff changeset	451 java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	452 _long_mirror =
a61af66fc99e Initial load duke parents: diff changeset	453 java_lang_Class::create_basic_type_mirror("long", T_LONG, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	454 _short_mirror =
a61af66fc99e Initial load duke parents: diff changeset	455 java_lang_Class::create_basic_type_mirror("short", T_SHORT, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	456 _void_mirror =
a61af66fc99e Initial load duke parents: diff changeset	457 java_lang_Class::create_basic_type_mirror("void", T_VOID, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	458
a61af66fc99e Initial load duke parents: diff changeset	459 _mirrors[T_INT] = _int_mirror;
a61af66fc99e Initial load duke parents: diff changeset	460 _mirrors[T_FLOAT] = _float_mirror;
a61af66fc99e Initial load duke parents: diff changeset	461 _mirrors[T_DOUBLE] = _double_mirror;
a61af66fc99e Initial load duke parents: diff changeset	462 _mirrors[T_BYTE] = _byte_mirror;
a61af66fc99e Initial load duke parents: diff changeset	463 _mirrors[T_BOOLEAN] = _bool_mirror;
a61af66fc99e Initial load duke parents: diff changeset	464 _mirrors[T_CHAR] = _char_mirror;
a61af66fc99e Initial load duke parents: diff changeset	465 _mirrors[T_LONG] = _long_mirror;
a61af66fc99e Initial load duke parents: diff changeset	466 _mirrors[T_SHORT] = _short_mirror;
a61af66fc99e Initial load duke parents: diff changeset	467 _mirrors[T_VOID] = _void_mirror;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	468 //_mirrors[T_OBJECT] = InstanceKlass::cast(_object_klass)->java_mirror();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	469 //_mirrors[T_ARRAY] = InstanceKlass::cast(_object_klass)->java_mirror();
0 a61af66fc99e Initial load duke parents: diff changeset	470 }
a61af66fc99e Initial load duke parents: diff changeset	471
a61af66fc99e Initial load duke parents: diff changeset	472 void Universe::fixup_mirrors(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	473 // Bootstrap problem: all classes gets a mirror (java.lang.Class instance) assigned eagerly,
a61af66fc99e Initial load duke parents: diff changeset	474 // but we cannot do that for classes created before java.lang.Class is loaded. Here we simply
a61af66fc99e Initial load duke parents: diff changeset	475 // walk over permanent objects created so far (mostly classes) and fixup their mirrors. Note
a61af66fc99e Initial load duke parents: diff changeset	476 // that the number of objects allocated at this point is very small.
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	477 assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	478 HandleMark hm(THREAD);
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2375 diff changeset	479 // Cache the start of the static fields
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	480 InstanceMirrorKlass::init_offset_of_static_fields();
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2375 diff changeset	481
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	482 GrowableArray <Klass> list = java_lang_Class::fixup_mirror_list();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	483 int list_length = list->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	484 for (int i = 0; i < list_length; i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	485 Klass* k = list->at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	486 assert(k->is_klass(), "List should only hold classes");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	487 EXCEPTION_MARK;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	488 KlassHandle kh(THREAD, k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	489 java_lang_Class::fixup_mirror(kh, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	490 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	491 delete java_lang_Class::fixup_mirror_list();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	492 java_lang_Class::set_fixup_mirror_list(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	493 }
0 a61af66fc99e Initial load duke parents: diff changeset	494
a61af66fc99e Initial load duke parents: diff changeset	495 static bool has_run_finalizers_on_exit = false;
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497 void Universe::run_finalizers_on_exit() {
a61af66fc99e Initial load duke parents: diff changeset	498 if (has_run_finalizers_on_exit) return;
a61af66fc99e Initial load duke parents: diff changeset	499 has_run_finalizers_on_exit = true;
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 // Called on VM exit. This ought to be run in a separate thread.
a61af66fc99e Initial load duke parents: diff changeset	502 if (TraceReferenceGC) tty->print_cr("Callback to run finalizers on exit");
a61af66fc99e Initial load duke parents: diff changeset	503 {
a61af66fc99e Initial load duke parents: diff changeset	504 PRESERVE_EXCEPTION_MARK;
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	505 KlassHandle finalizer_klass(THREAD, SystemDictionary::Finalizer_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	506 JavaValue result(T_VOID);
a61af66fc99e Initial load duke parents: diff changeset	507 JavaCalls::call_static(
a61af66fc99e Initial load duke parents: diff changeset	508 &result,
a61af66fc99e Initial load duke parents: diff changeset	509 finalizer_klass,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	510 vmSymbols::run_finalizers_on_exit_name(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	511 vmSymbols::void_method_signature(),
0 a61af66fc99e Initial load duke parents: diff changeset	512 THREAD
a61af66fc99e Initial load duke parents: diff changeset	513 );
a61af66fc99e Initial load duke parents: diff changeset	514 // Ignore any pending exceptions
a61af66fc99e Initial load duke parents: diff changeset	515 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517 }
a61af66fc99e Initial load duke parents: diff changeset	518
a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520 // initialize_vtable could cause gc if
a61af66fc99e Initial load duke parents: diff changeset	521 // 1) we specified true to initialize_vtable and
a61af66fc99e Initial load duke parents: diff changeset	522 // 2) this ran after gc was enabled
a61af66fc99e Initial load duke parents: diff changeset	523 // In case those ever change we use handles for oops
a61af66fc99e Initial load duke parents: diff changeset	524 void Universe::reinitialize_vtable_of(KlassHandle k_h, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	525 // init vtable of k and all subclasses
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	526 Klass* ko = k_h();
0 a61af66fc99e Initial load duke parents: diff changeset	527 klassVtable* vt = ko->vtable();
a61af66fc99e Initial load duke parents: diff changeset	528 if (vt) vt->initialize_vtable(false, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	529 if (ko->oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	530 InstanceKlass* ik = (InstanceKlass*)ko;
10973 ef57c43512d6 8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux ccheung parents: 10405 diff changeset	531 for (KlassHandle s_h(THREAD, ik->subklass());
ef57c43512d6 8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux ccheung parents: 10405 diff changeset	532 s_h() != NULL;
ef57c43512d6 8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux ccheung parents: 10405 diff changeset	533 s_h = KlassHandle(THREAD, s_h()->next_sibling())) {
0 a61af66fc99e Initial load duke parents: diff changeset	534 reinitialize_vtable_of(s_h, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	535 }
a61af66fc99e Initial load duke parents: diff changeset	536 }
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	540 void initialize_itable_for_klass(Klass* k, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	541 InstanceKlass::cast(k)->itable()->initialize_itable(false, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	542 }
a61af66fc99e Initial load duke parents: diff changeset	543
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 void Universe::reinitialize_itables(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	546 SystemDictionary::classes_do(initialize_itable_for_klass, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548 }
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550
a61af66fc99e Initial load duke parents: diff changeset	551 bool Universe::on_page_boundary(void* addr) {
a61af66fc99e Initial load duke parents: diff changeset	552 return ((uintptr_t) addr) % os::vm_page_size() == 0;
a61af66fc99e Initial load duke parents: diff changeset	553 }
a61af66fc99e Initial load duke parents: diff changeset	554
a61af66fc99e Initial load duke parents: diff changeset	555
a61af66fc99e Initial load duke parents: diff changeset	556 bool Universe::should_fill_in_stack_trace(Handle throwable) {
a61af66fc99e Initial load duke parents: diff changeset	557 // never attempt to fill in the stack trace of preallocated errors that do not have
a61af66fc99e Initial load duke parents: diff changeset	558 // backtrace. These errors are kept alive forever and may be "re-used" when all
a61af66fc99e Initial load duke parents: diff changeset	559 // preallocated errors with backtrace have been consumed. Also need to avoid
a61af66fc99e Initial load duke parents: diff changeset	560 // a potential loop which could happen if an out of memory occurs when attempting
a61af66fc99e Initial load duke parents: diff changeset	561 // to allocate the backtrace.
a61af66fc99e Initial load duke parents: diff changeset	562 return ((throwable() != Universe::_out_of_memory_error_java_heap) &&
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	563 (throwable() != Universe::_out_of_memory_error_metaspace) &&
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	564 (throwable() != Universe::_out_of_memory_error_class_metaspace) &&
0 a61af66fc99e Initial load duke parents: diff changeset	565 (throwable() != Universe::_out_of_memory_error_array_size) &&
a61af66fc99e Initial load duke parents: diff changeset	566 (throwable() != Universe::_out_of_memory_error_gc_overhead_limit));
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569
a61af66fc99e Initial load duke parents: diff changeset	570 oop Universe::gen_out_of_memory_error(oop default_err) {
a61af66fc99e Initial load duke parents: diff changeset	571 // generate an out of memory error:
a61af66fc99e Initial load duke parents: diff changeset	572 // - if there is a preallocated error with backtrace available then return it wth
a61af66fc99e Initial load duke parents: diff changeset	573 // a filled in stack trace.
a61af66fc99e Initial load duke parents: diff changeset	574 // - if there are no preallocated errors with backtrace available then return
a61af66fc99e Initial load duke parents: diff changeset	575 // an error without backtrace.
a61af66fc99e Initial load duke parents: diff changeset	576 int next;
a61af66fc99e Initial load duke parents: diff changeset	577 if (_preallocated_out_of_memory_error_avail_count > 0) {
a61af66fc99e Initial load duke parents: diff changeset	578 next = (int)Atomic::add(-1, &_preallocated_out_of_memory_error_avail_count);
a61af66fc99e Initial load duke parents: diff changeset	579 assert(next < (int)PreallocatedOutOfMemoryErrorCount, "avail count is corrupt");
a61af66fc99e Initial load duke parents: diff changeset	580 } else {
a61af66fc99e Initial load duke parents: diff changeset	581 next = -1;
a61af66fc99e Initial load duke parents: diff changeset	582 }
a61af66fc99e Initial load duke parents: diff changeset	583 if (next < 0) {
a61af66fc99e Initial load duke parents: diff changeset	584 // all preallocated errors have been used.
a61af66fc99e Initial load duke parents: diff changeset	585 // return default
a61af66fc99e Initial load duke parents: diff changeset	586 return default_err;
a61af66fc99e Initial load duke parents: diff changeset	587 } else {
a61af66fc99e Initial load duke parents: diff changeset	588 // get the error object at the slot and set set it to NULL so that the
a61af66fc99e Initial load duke parents: diff changeset	589 // array isn't keeping it alive anymore.
a61af66fc99e Initial load duke parents: diff changeset	590 oop exc = preallocated_out_of_memory_errors()->obj_at(next);
a61af66fc99e Initial load duke parents: diff changeset	591 assert(exc != NULL, "slot has been used already");
a61af66fc99e Initial load duke parents: diff changeset	592 preallocated_out_of_memory_errors()->obj_at_put(next, NULL);
a61af66fc99e Initial load duke parents: diff changeset	593
a61af66fc99e Initial load duke parents: diff changeset	594 // use the message from the default error
a61af66fc99e Initial load duke parents: diff changeset	595 oop msg = java_lang_Throwable::message(default_err);
a61af66fc99e Initial load duke parents: diff changeset	596 assert(msg != NULL, "no message");
a61af66fc99e Initial load duke parents: diff changeset	597 java_lang_Throwable::set_message(exc, msg);
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599 // populate the stack trace and return it.
a61af66fc99e Initial load duke parents: diff changeset	600 java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(exc);
a61af66fc99e Initial load duke parents: diff changeset	601 return exc;
a61af66fc99e Initial load duke parents: diff changeset	602 }
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 static intptr_t non_oop_bits = 0;
a61af66fc99e Initial load duke parents: diff changeset	606
a61af66fc99e Initial load duke parents: diff changeset	607 void* Universe::non_oop_word() {
a61af66fc99e Initial load duke parents: diff changeset	608 // Neither the high bits nor the low bits of this value is allowed
a61af66fc99e Initial load duke parents: diff changeset	609 // to look like (respectively) the high or low bits of a real oop.
a61af66fc99e Initial load duke parents: diff changeset	610 //
a61af66fc99e Initial load duke parents: diff changeset	611 // High and low are CPU-specific notions, but low always includes
a61af66fc99e Initial load duke parents: diff changeset	612 // the low-order bit. Since oops are always aligned at least mod 4,
a61af66fc99e Initial load duke parents: diff changeset	613 // setting the low-order bit will ensure that the low half of the
a61af66fc99e Initial load duke parents: diff changeset	614 // word will never look like that of a real oop.
a61af66fc99e Initial load duke parents: diff changeset	615 //
a61af66fc99e Initial load duke parents: diff changeset	616 // Using the OS-supplied non-memory-address word (usually 0 or -1)
a61af66fc99e Initial load duke parents: diff changeset	617 // will take care of the high bits, however many there are.
a61af66fc99e Initial load duke parents: diff changeset	618
a61af66fc99e Initial load duke parents: diff changeset	619 if (non_oop_bits == 0) {
a61af66fc99e Initial load duke parents: diff changeset	620 non_oop_bits = (intptr_t)os::non_memory_address_word() \| 1;
a61af66fc99e Initial load duke parents: diff changeset	621 }
a61af66fc99e Initial load duke parents: diff changeset	622
a61af66fc99e Initial load duke parents: diff changeset	623 return (void*)non_oop_bits;
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
a61af66fc99e Initial load duke parents: diff changeset	626 jint universe_init() {
a61af66fc99e Initial load duke parents: diff changeset	627 assert(!Universe::_fully_initialized, "called after initialize_vtables");
a61af66fc99e Initial load duke parents: diff changeset	628 guarantee(1 << LogHeapWordSize == sizeof(HeapWord),
a61af66fc99e Initial load duke parents: diff changeset	629 "LogHeapWordSize is incorrect.");
a61af66fc99e Initial load duke parents: diff changeset	630 guarantee(sizeof(oop) >= sizeof(HeapWord), "HeapWord larger than oop?");
a61af66fc99e Initial load duke parents: diff changeset	631 guarantee(sizeof(oop) % sizeof(HeapWord) == 0,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	632 "oop size is not not a multiple of HeapWord size");
0 a61af66fc99e Initial load duke parents: diff changeset	633 TraceTime timer("Genesis", TraceStartupTime);
a61af66fc99e Initial load duke parents: diff changeset	634 GC_locker::lock(); // do not allow gc during bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	635 JavaClasses::compute_hard_coded_offsets();
a61af66fc99e Initial load duke parents: diff changeset	636
a61af66fc99e Initial load duke parents: diff changeset	637 jint status = Universe::initialize_heap();
a61af66fc99e Initial load duke parents: diff changeset	638 if (status != JNI_OK) {
a61af66fc99e Initial load duke parents: diff changeset	639 return status;
a61af66fc99e Initial load duke parents: diff changeset	640 }
a61af66fc99e Initial load duke parents: diff changeset	641
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	642 Metaspace::global_initialize();
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	643
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	644 // Create memory for metadata. Must be after initializing heap for
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	645 // DumpSharedSpaces.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	646 ClassLoaderData::init_null_class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	647
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	648 // We have a heap so create the Method* caches before
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	649 // Metaspace::initialize_shared_spaces() tries to populate them.
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	650 Universe::_finalizer_register_cache = new LatestMethodCache();
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	651 Universe::_loader_addClass_cache = new LatestMethodCache();
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	652 Universe::_pd_implies_cache = new LatestMethodCache();
0 a61af66fc99e Initial load duke parents: diff changeset	653
a61af66fc99e Initial load duke parents: diff changeset	654 if (UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	655 // Read the data structures supporting the shared spaces (shared
a61af66fc99e Initial load duke parents: diff changeset	656 // system dictionary, symbol table, etc.). After that, access to
a61af66fc99e Initial load duke parents: diff changeset	657 // the file (other than the mapped regions) is no longer needed, and
a61af66fc99e Initial load duke parents: diff changeset	658 // the file is closed. Closing the file does not affect the
a61af66fc99e Initial load duke parents: diff changeset	659 // currently mapped regions.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	660 MetaspaceShared::initialize_shared_spaces();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	661 StringTable::create_table();
0 a61af66fc99e Initial load duke parents: diff changeset	662 } else {
a61af66fc99e Initial load duke parents: diff changeset	663 SymbolTable::create_table();
a61af66fc99e Initial load duke parents: diff changeset	664 StringTable::create_table();
a61af66fc99e Initial load duke parents: diff changeset	665 ClassLoader::create_package_info_table();
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667
a61af66fc99e Initial load duke parents: diff changeset	668 return JNI_OK;
a61af66fc99e Initial load duke parents: diff changeset	669 }
a61af66fc99e Initial load duke parents: diff changeset	670
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	671 // Choose the heap base address and oop encoding mode
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	672 // when compressed oops are used:
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	673 // Unscaled - Use 32-bits oops without encoding when
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	674 // NarrowOopHeapBaseMin + heap_size < 4Gb
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	675 // ZeroBased - Use zero based compressed oops with encoding when
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	676 // NarrowOopHeapBaseMin + heap_size < 32Gb
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	677 // HeapBased - Use compressed oops with heap base + encoding.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	678
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	679 // 4Gb
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	680 static const uint64_t NarrowOopHeapMax = (uint64_t(max_juint) + 1);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	681 // 32Gb
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1507 diff changeset	682 // OopEncodingHeapMax == NarrowOopHeapMax << LogMinObjAlignmentInBytes;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	683
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	684 char* Universe::preferred_heap_base(size_t heap_size, size_t alignment, NARROW_OOP_MODE mode) {
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	685 assert(is_size_aligned((size_t)OopEncodingHeapMax, alignment), "Must be");
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	686 assert(is_size_aligned((size_t)NarrowOopHeapMax, alignment), "Must be");
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	687 assert(is_size_aligned(heap_size, alignment), "Must be");
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	688
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	689 uintx heap_base_min_address_aligned = align_size_up(HeapBaseMinAddress, alignment);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	690
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	691 size_t base = 0;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	692 #ifdef _LP64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	693 if (UseCompressedOops) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	694 assert(mode == UnscaledNarrowOop \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	695 mode == ZeroBasedNarrowOop \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	696 mode == HeapBasedNarrowOop, "mode is invalid");
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	697 const size_t total_size = heap_size + heap_base_min_address_aligned;
922 1a81ea4b45d4 6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop") kvn parents: 845 diff changeset	698 // Return specified base for the first request.
1a81ea4b45d4 6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop") kvn parents: 845 diff changeset	699 if (!FLAG_IS_DEFAULT(HeapBaseMinAddress) && (mode == UnscaledNarrowOop)) {
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	700 base = heap_base_min_address_aligned;
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 7623 diff changeset	701
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	702 // If the total size is small enough to allow UnscaledNarrowOop then
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	703 // just use UnscaledNarrowOop.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	704 } else if ((total_size <= OopEncodingHeapMax) && (mode != HeapBasedNarrowOop)) {
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 7623 diff changeset	705 if ((total_size <= NarrowOopHeapMax) && (mode == UnscaledNarrowOop) &&
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	706 (Universe::narrow_oop_shift() == 0)) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	707 // Use 32-bits oops without encoding and
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	708 // place heap's top on the 4Gb boundary
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	709 base = (NarrowOopHeapMax - heap_size);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	710 } else {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	711 // Can't reserve with NarrowOopShift == 0
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	712 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	713 if (mode == UnscaledNarrowOop \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	714 mode == ZeroBasedNarrowOop && total_size <= NarrowOopHeapMax) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	715 // Use zero based compressed oops with encoding and
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	716 // place heap's top on the 32Gb boundary in case
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	717 // total_size > 4Gb or failed to reserve below 4Gb.
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	718 base = (OopEncodingHeapMax - heap_size);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	719 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	720 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	721 } else {
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 7623 diff changeset	722 // UnscaledNarrowOop encoding didn't work, and no base was found for ZeroBasedOops or
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 7623 diff changeset	723 // HeapBasedNarrowOop encoding was requested. So, can't reserve below 32Gb.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	724 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	725 }
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 7623 diff changeset	726
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	727 // Set narrow_oop_base and narrow_oop_use_implicit_null_checks
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	728 // used in ReservedHeapSpace() constructors.
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	729 // The final values will be set in initialize_heap() below.
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	730 if ((base != 0) && ((base + heap_size) <= OopEncodingHeapMax)) {
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	731 // Use zero based compressed oops
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	732 Universe::set_narrow_oop_base(NULL);
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	733 // Don't need guard page for implicit checks in indexed
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	734 // addressing mode with zero based Compressed Oops.
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	735 Universe::set_narrow_oop_use_implicit_null_checks(true);
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	736 } else {
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	737 // Set to a non-NULL value so the ReservedSpace ctor computes
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	738 // the correct no-access prefix.
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	739 // The final value will be set in initialize_heap() below.
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	740 Universe::set_narrow_oop_base((address)NarrowOopHeapMax);
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	741 #ifdef _WIN64
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	742 if (UseLargePages) {
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	743 // Cannot allocate guard pages for implicit checks in indexed
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	744 // addressing mode when large pages are specified on windows.
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	745 Universe::set_narrow_oop_use_implicit_null_checks(false);
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	746 }
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	747 #endif // _WIN64
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	748 }
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	749 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	750 #endif
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	751
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	752 assert(is_ptr_aligned((char*)base, alignment), "Must be");
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	753 return (char*)base; // also return NULL (don't care) for 32-bit VM
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	754 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	755
0 a61af66fc99e Initial load duke parents: diff changeset	756 jint Universe::initialize_heap() {
a61af66fc99e Initial load duke parents: diff changeset	757
a61af66fc99e Initial load duke parents: diff changeset	758 if (UseParallelGC) {
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	759 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	760 Universe::_collectedHeap = new ParallelScavengeHeap();
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	761 #else // INCLUDE_ALL_GCS
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6751 diff changeset	762 fatal("UseParallelGC not supported in this VM.");
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	763 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	764
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	765 } else if (UseG1GC) {
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	766 #if INCLUDE_ALL_GCS
4013 074f0252cc13 7088680: G1: Cleanup in the G1CollectorPolicy class tonyp parents: 3960 diff changeset	767 G1CollectorPolicy* g1p = new G1CollectorPolicy();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	768 G1CollectedHeap* g1h = new G1CollectedHeap(g1p);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	769 Universe::_collectedHeap = g1h;
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	770 #else // INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	771 fatal("UseG1GC not supported in java kernel vm.");
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	772 #endif // INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	773
0 a61af66fc99e Initial load duke parents: diff changeset	774 } else {
a61af66fc99e Initial load duke parents: diff changeset	775 GenCollectorPolicy *gc_policy;
a61af66fc99e Initial load duke parents: diff changeset	776
a61af66fc99e Initial load duke parents: diff changeset	777 if (UseSerialGC) {
a61af66fc99e Initial load duke parents: diff changeset	778 gc_policy = new MarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	779 } else if (UseConcMarkSweepGC) {
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	780 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	781 if (UseAdaptiveSizePolicy) {
a61af66fc99e Initial load duke parents: diff changeset	782 gc_policy = new ASConcurrentMarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	783 } else {
a61af66fc99e Initial load duke parents: diff changeset	784 gc_policy = new ConcurrentMarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	785 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	786 #else // INCLUDE_ALL_GCS
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6751 diff changeset	787 fatal("UseConcMarkSweepGC not supported in this VM.");
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7187 diff changeset	788 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	789 } else { // default old generation
a61af66fc99e Initial load duke parents: diff changeset	790 gc_policy = new MarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	791 }
a61af66fc99e Initial load duke parents: diff changeset	792
a61af66fc99e Initial load duke parents: diff changeset	793 Universe::_collectedHeap = new GenCollectedHeap(gc_policy);
a61af66fc99e Initial load duke parents: diff changeset	794 }
a61af66fc99e Initial load duke parents: diff changeset	795
a61af66fc99e Initial load duke parents: diff changeset	796 jint status = Universe::heap()->initialize();
a61af66fc99e Initial load duke parents: diff changeset	797 if (status != JNI_OK) {
a61af66fc99e Initial load duke parents: diff changeset	798 return status;
a61af66fc99e Initial load duke parents: diff changeset	799 }
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	800
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	801 #ifdef _LP64
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	802 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	803 // Subtract a page because something can get allocated at heap base.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	804 // This also makes implicit null checking work, because the
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	805 // memory+1 page below heap_base needs to cause a signal.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	806 // See needs_explicit_null_check.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	807 // Only set the heap base for compressed oops because it indicates
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	808 // compressed oops for pstack code.
2080 c04052fd6ae1 7006505: Use kstat info to identify SPARC processor kvn parents: 1972 diff changeset	809 bool verbose = PrintCompressedOopsMode \|\| (PrintMiscellaneous && Verbose);
c04052fd6ae1 7006505: Use kstat info to identify SPARC processor kvn parents: 1972 diff changeset	810 if (verbose) {
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	811 tty->cr();
1963 0ac62b4d6507 6999491: non-zero COOPs are used when they should not kvn parents: 1579 diff changeset	812 tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB",
0ac62b4d6507 6999491: non-zero COOPs are used when they should not kvn parents: 1579 diff changeset	813 Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	814 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	815 if (((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax)) {
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	816 // Can't reserve heap below 32Gb.
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	817 // keep the Universe::narrow_oop_base() set in Universe::reserve_heap()
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	818 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
2080 c04052fd6ae1 7006505: Use kstat info to identify SPARC processor kvn parents: 1972 diff changeset	819 if (verbose) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	820 tty->print(", %s: "PTR_FORMAT,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	821 narrow_oop_mode_to_string(HeapBasedNarrowOop),
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	822 Universe::narrow_oop_base());
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	823 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	824 } else {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	825 Universe::set_narrow_oop_base(0);
2080 c04052fd6ae1 7006505: Use kstat info to identify SPARC processor kvn parents: 1972 diff changeset	826 if (verbose) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	827 tty->print(", %s", narrow_oop_mode_to_string(ZeroBasedNarrowOop));
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	828 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	829 #ifdef _WIN64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	830 if (!Universe::narrow_oop_use_implicit_null_checks()) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	831 // Don't need guard page for implicit checks in indexed addressing
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	832 // mode with zero based Compressed Oops.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	833 Universe::set_narrow_oop_use_implicit_null_checks(true);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	834 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	835 #endif // _WIN64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	836 if((uint64_t)Universe::heap()->reserved_region().end() > NarrowOopHeapMax) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	837 // Can't reserve heap below 4Gb.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	838 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	839 } else {
922 1a81ea4b45d4 6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop") kvn parents: 845 diff changeset	840 Universe::set_narrow_oop_shift(0);
2080 c04052fd6ae1 7006505: Use kstat info to identify SPARC processor kvn parents: 1972 diff changeset	841 if (verbose) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	842 tty->print(", %s", narrow_oop_mode_to_string(UnscaledNarrowOop));
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	843 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	844 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	845 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	846
2080 c04052fd6ae1 7006505: Use kstat info to identify SPARC processor kvn parents: 1972 diff changeset	847 if (verbose) {
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	848 tty->cr();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	849 tty->cr();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	850 }
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	851 Universe::set_narrow_ptrs_base(Universe::narrow_oop_base());
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	852 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	853 // Universe::narrow_oop_base() is one page below the heap.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	854 assert((intptr_t)Universe::narrow_oop_base() <= (intptr_t)(Universe::heap()->base() -
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	855 os::vm_page_size()) \|\|
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	856 Universe::narrow_oop_base() == NULL, "invalid value");
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	857 assert(Universe::narrow_oop_shift() == LogMinObjAlignmentInBytes \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	858 Universe::narrow_oop_shift() == 0, "invalid value");
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	859 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	860
a61af66fc99e Initial load duke parents: diff changeset	861 // We will never reach the CATCH below since Exceptions::_throw will cause
a61af66fc99e Initial load duke parents: diff changeset	862 // the VM to exit if an exception is thrown during initialization
a61af66fc99e Initial load duke parents: diff changeset	863
a61af66fc99e Initial load duke parents: diff changeset	864 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	865 assert(Universe::heap()->supports_tlab_allocation(),
a61af66fc99e Initial load duke parents: diff changeset	866 "Should support thread-local allocation buffers");
a61af66fc99e Initial load duke parents: diff changeset	867 ThreadLocalAllocBuffer::startup_initialization();
a61af66fc99e Initial load duke parents: diff changeset	868 }
a61af66fc99e Initial load duke parents: diff changeset	869 return JNI_OK;
a61af66fc99e Initial load duke parents: diff changeset	870 }
a61af66fc99e Initial load duke parents: diff changeset	871
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	872
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	873 // Reserve the Java heap, which is now the same for all GCs.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	874 ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) {
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12226 diff changeset	875 assert(alignment <= Arguments::conservative_max_heap_alignment(),
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12226 diff changeset	876 err_msg("actual alignment "SIZE_FORMAT" must be within maximum heap alignment "SIZE_FORMAT,
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12226 diff changeset	877 alignment, Arguments::conservative_max_heap_alignment()));
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	878 size_t total_reserved = align_size_up(heap_size, alignment);
8741 eac371996b44 8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes brutisso parents: 8003 diff changeset	879 assert(!UseCompressedOops \|\| (total_reserved <= (OopEncodingHeapMax - os::vm_page_size())),
eac371996b44 8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes brutisso parents: 8003 diff changeset	880 "heap size is too big for compressed oops");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	881
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	882 bool use_large_pages = UseLargePages && is_size_aligned(alignment, os::large_page_size());
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	883 assert(!UseLargePages
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	884 \|\| UseParallelOldGC
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	885 \|\| use_large_pages, "Wrong alignment to use large pages");
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	886
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	887 char* addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::UnscaledNarrowOop);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	888
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	889 ReservedHeapSpace total_rs(total_reserved, alignment, use_large_pages, addr);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	890
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	891 if (UseCompressedOops) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	892 if (addr != NULL && !total_rs.is_reserved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	893 // Failed to reserve at specified address - the requested memory
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	894 // region is taken already, for example, by 'java' launcher.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	895 // Try again to reserver heap higher.
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	896 addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::ZeroBasedNarrowOop);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	897
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	898 ReservedHeapSpace total_rs0(total_reserved, alignment,
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	899 use_large_pages, addr);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	900
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	901 if (addr != NULL && !total_rs0.is_reserved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	902 // Failed to reserve at specified address again - give up.
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	903 addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::HeapBasedNarrowOop);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	904 assert(addr == NULL, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	905
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	906 ReservedHeapSpace total_rs1(total_reserved, alignment,
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12063 diff changeset	907 use_large_pages, addr);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	908 total_rs = total_rs1;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	909 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	910 total_rs = total_rs0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	911 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	912 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	913 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	914
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	915 if (!total_rs.is_reserved()) {
10358 0def34ab1c98 8015007: Incorrect print format in error message for VM cannot allocate the requested heap tamao parents: 10265 diff changeset	916 vm_exit_during_initialization(err_msg("Could not reserve enough space for " SIZE_FORMAT "KB object heap", total_reserved/K));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	917 return total_rs;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	918 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	919
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	920 if (UseCompressedOops) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	921 // Universe::initialize_heap() will reset this to NULL if unscaled
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	922 // or zero-based narrow oops are actually used.
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	923 address base = (address)(total_rs.base() - os::vm_page_size());
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	924 Universe::set_narrow_oop_base(base);
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	925 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	926 return total_rs;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	927 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	928
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	929
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	930 // It's the caller's responsibility to ensure glitch-freedom
0 a61af66fc99e Initial load duke parents: diff changeset	931 // (if required).
a61af66fc99e Initial load duke parents: diff changeset	932 void Universe::update_heap_info_at_gc() {
a61af66fc99e Initial load duke parents: diff changeset	933 _heap_capacity_at_last_gc = heap()->capacity();
a61af66fc99e Initial load duke parents: diff changeset	934 _heap_used_at_last_gc = heap()->used();
a61af66fc99e Initial load duke parents: diff changeset	935 }
a61af66fc99e Initial load duke parents: diff changeset	936
a61af66fc99e Initial load duke parents: diff changeset	937
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	938 const char* Universe::narrow_oop_mode_to_string(Universe::NARROW_OOP_MODE mode) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	939 switch (mode) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	940 case UnscaledNarrowOop:
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	941 return "32-bits Oops";
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	942 case ZeroBasedNarrowOop:
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	943 return "zero based Compressed Oops";
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	944 case HeapBasedNarrowOop:
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	945 return "Compressed Oops with base";
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	946 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	947
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	948 ShouldNotReachHere();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	949 return "";
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	950 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	951
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	952
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	953 Universe::NARROW_OOP_MODE Universe::narrow_oop_mode() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	954 if (narrow_oop_base() != 0) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	955 return HeapBasedNarrowOop;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	956 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	957
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	958 if (narrow_oop_shift() != 0) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	959 return ZeroBasedNarrowOop;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	960 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	961
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	962 return UnscaledNarrowOop;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	963 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10358 diff changeset	964
0 a61af66fc99e Initial load duke parents: diff changeset	965
a61af66fc99e Initial load duke parents: diff changeset	966 void universe2_init() {
a61af66fc99e Initial load duke parents: diff changeset	967 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	968 Universe::genesis(CATCH);
a61af66fc99e Initial load duke parents: diff changeset	969 }
a61af66fc99e Initial load duke parents: diff changeset	970
a61af66fc99e Initial load duke parents: diff changeset	971
a61af66fc99e Initial load duke parents: diff changeset	972 // This function is defined in JVM.cpp
a61af66fc99e Initial load duke parents: diff changeset	973 extern void initialize_converter_functions();
a61af66fc99e Initial load duke parents: diff changeset	974
a61af66fc99e Initial load duke parents: diff changeset	975 bool universe_post_init() {
1959 9eecf81a02fb 7000578: CMS: assert(SafepointSynchronize::is_at_safepoint()) failed: Else races are possible ysr parents: 1579 diff changeset	976 assert(!is_init_completed(), "Error: initialization not yet completed!");
0 a61af66fc99e Initial load duke parents: diff changeset	977 Universe::_fully_initialized = true;
a61af66fc99e Initial load duke parents: diff changeset	978 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	979 { ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	980 Interpreter::initialize(); // needed for interpreter entry points
a61af66fc99e Initial load duke parents: diff changeset	981 if (!UseSharedSpaces) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	982 HandleMark hm(THREAD);
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	983 KlassHandle ok_h(THREAD, SystemDictionary::Object_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	984 Universe::reinitialize_vtable_of(ok_h, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	985 Universe::reinitialize_itables(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	986 }
a61af66fc99e Initial load duke parents: diff changeset	987 }
a61af66fc99e Initial load duke parents: diff changeset	988
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	989 HandleMark hm(THREAD);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	990 Klass* k;
0 a61af66fc99e Initial load duke parents: diff changeset	991 instanceKlassHandle k_h;
a61af66fc99e Initial load duke parents: diff changeset	992 // Setup preallocated empty java.lang.Class array
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	993 Universe::_the_empty_class_klass_array = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_false);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	994
0 a61af66fc99e Initial load duke parents: diff changeset	995 // Setup preallocated OutOfMemoryError errors
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	996 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_OutOfMemoryError(), true, CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	997 k_h = instanceKlassHandle(THREAD, k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	998 Universe::_out_of_memory_error_java_heap = k_h->allocate_instance(CHECK_false);
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	999 Universe::_out_of_memory_error_metaspace = k_h->allocate_instance(CHECK_false);
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	1000 Universe::_out_of_memory_error_class_metaspace = k_h->allocate_instance(CHECK_false);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1001 Universe::_out_of_memory_error_array_size = k_h->allocate_instance(CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1002 Universe::_out_of_memory_error_gc_overhead_limit =
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1003 k_h->allocate_instance(CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1004
a61af66fc99e Initial load duke parents: diff changeset	1005 // Setup preallocated NullPointerException
a61af66fc99e Initial load duke parents: diff changeset	1006 // (this is currently used for a cheap & dirty solution in compiler exception handling)
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	1007 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_NullPointerException(), true, CHECK_false);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1008 Universe::_null_ptr_exception_instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1009 // Setup preallocated ArithmeticException
a61af66fc99e Initial load duke parents: diff changeset	1010 // (this is currently used for a cheap & dirty solution in compiler exception handling)
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	1011 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ArithmeticException(), true, CHECK_false);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1012 Universe::_arithmetic_exception_instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1013 // Virtual Machine Error for when we get into a situation we can't resolve
a61af66fc99e Initial load duke parents: diff changeset	1014 k = SystemDictionary::resolve_or_fail(
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	1015 vmSymbols::java_lang_VirtualMachineError(), true, CHECK_false);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1016 bool linked = InstanceKlass::cast(k)->link_class_or_fail(CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1017 if (!linked) {
a61af66fc99e Initial load duke parents: diff changeset	1018 tty->print_cr("Unable to link/verify VirtualMachineError class");
a61af66fc99e Initial load duke parents: diff changeset	1019 return false; // initialization failed
a61af66fc99e Initial load duke parents: diff changeset	1020 }
a61af66fc99e Initial load duke parents: diff changeset	1021 Universe::_virtual_machine_error_instance =
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1022 InstanceKlass::cast(k)->allocate_instance(CHECK_false);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	1023
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1024 Universe::_vm_exception = InstanceKlass::cast(k)->allocate_instance(CHECK_false);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2080 diff changeset	1025
0 a61af66fc99e Initial load duke parents: diff changeset	1026 if (!DumpSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	1027 // These are the only Java fields that are currently set during shared space dumping.
a61af66fc99e Initial load duke parents: diff changeset	1028 // We prefer to not handle this generally, so we always reinitialize these detail messages.
a61af66fc99e Initial load duke parents: diff changeset	1029 Handle msg = java_lang_String::create_from_str("Java heap space", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1030 java_lang_Throwable::set_message(Universe::_out_of_memory_error_java_heap, msg());
a61af66fc99e Initial load duke parents: diff changeset	1031
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1032 msg = java_lang_String::create_from_str("Metadata space", CHECK_false);
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	1033 java_lang_Throwable::set_message(Universe::_out_of_memory_error_metaspace, msg());
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	1034 msg = java_lang_String::create_from_str("Compressed class space", CHECK_false);
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10973 diff changeset	1035 java_lang_Throwable::set_message(Universe::_out_of_memory_error_class_metaspace, msg());
0 a61af66fc99e Initial load duke parents: diff changeset	1036
a61af66fc99e Initial load duke parents: diff changeset	1037 msg = java_lang_String::create_from_str("Requested array size exceeds VM limit", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1038 java_lang_Throwable::set_message(Universe::_out_of_memory_error_array_size, msg());
a61af66fc99e Initial load duke parents: diff changeset	1039
a61af66fc99e Initial load duke parents: diff changeset	1040 msg = java_lang_String::create_from_str("GC overhead limit exceeded", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1041 java_lang_Throwable::set_message(Universe::_out_of_memory_error_gc_overhead_limit, msg());
a61af66fc99e Initial load duke parents: diff changeset	1042
a61af66fc99e Initial load duke parents: diff changeset	1043 msg = java_lang_String::create_from_str("/ by zero", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1044 java_lang_Throwable::set_message(Universe::_arithmetic_exception_instance, msg());
a61af66fc99e Initial load duke parents: diff changeset	1045
a61af66fc99e Initial load duke parents: diff changeset	1046 // Setup the array of errors that have preallocated backtrace
a61af66fc99e Initial load duke parents: diff changeset	1047 k = Universe::_out_of_memory_error_java_heap->klass();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1048 assert(k->name() == vmSymbols::java_lang_OutOfMemoryError(), "should be out of memory error");
0 a61af66fc99e Initial load duke parents: diff changeset	1049 k_h = instanceKlassHandle(THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	1050
a61af66fc99e Initial load duke parents: diff changeset	1051 int len = (StackTraceInThrowable) ? (int)PreallocatedOutOfMemoryErrorCount : 0;
a61af66fc99e Initial load duke parents: diff changeset	1052 Universe::_preallocated_out_of_memory_error_array = oopFactory::new_objArray(k_h(), len, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1053 for (int i=0; i<len; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1054 oop err = k_h->allocate_instance(CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1055 Handle err_h = Handle(THREAD, err);
a61af66fc99e Initial load duke parents: diff changeset	1056 java_lang_Throwable::allocate_backtrace(err_h, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1057 Universe::preallocated_out_of_memory_errors()->obj_at_put(i, err_h());
a61af66fc99e Initial load duke parents: diff changeset	1058 }
a61af66fc99e Initial load duke parents: diff changeset	1059 Universe::_preallocated_out_of_memory_error_avail_count = (jint)len;
a61af66fc99e Initial load duke parents: diff changeset	1060 }
a61af66fc99e Initial load duke parents: diff changeset	1061
a61af66fc99e Initial load duke parents: diff changeset	1062
a61af66fc99e Initial load duke parents: diff changeset	1063 // Setup static method for registering finalizers
a61af66fc99e Initial load duke parents: diff changeset	1064 // The finalizer klass must be linked before looking up the method, in
a61af66fc99e Initial load duke parents: diff changeset	1065 // case it needs to get rewritten.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1066 InstanceKlass::cast(SystemDictionary::Finalizer_klass())->link_class(CHECK_false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1067 Method* m = InstanceKlass::cast(SystemDictionary::Finalizer_klass())->find_method(
0 a61af66fc99e Initial load duke parents: diff changeset	1068 vmSymbols::register_method_name(),
a61af66fc99e Initial load duke parents: diff changeset	1069 vmSymbols::register_method_signature());
a61af66fc99e Initial load duke parents: diff changeset	1070 if (m == NULL \|\| !m->is_static()) {
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1071 tty->print_cr("Unable to link/verify Finalizer.register method");
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1072 return false; // initialization failed (cannot throw exception yet)
0 a61af66fc99e Initial load duke parents: diff changeset	1073 }
a61af66fc99e Initial load duke parents: diff changeset	1074 Universe::_finalizer_register_cache->init(
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1075 SystemDictionary::Finalizer_klass(), m);
0 a61af66fc99e Initial load duke parents: diff changeset	1076
6751 2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1077 // Setup method for registering loaded classes in class loader vector
2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1078 InstanceKlass::cast(SystemDictionary::ClassLoader_klass())->link_class(CHECK_false);
2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1079 m = InstanceKlass::cast(SystemDictionary::ClassLoader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature());
2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1080 if (m == NULL \|\| m->is_static()) {
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1081 tty->print_cr("Unable to link/verify ClassLoader.addClass method");
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1082 return false; // initialization failed (cannot throw exception yet)
6751 2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1083 }
2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1084 Universe::_loader_addClass_cache->init(
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1085 SystemDictionary::ClassLoader_klass(), m);
6751 2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6736 diff changeset	1086
11010 b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1087 // Setup method for checking protection domain
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1088 InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass())->link_class(CHECK_false);
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1089 m = InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass())->
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1090 find_method(vmSymbols::impliesCreateAccessControlContext_name(),
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1091 vmSymbols::void_boolean_signature());
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1092 // Allow NULL which should only happen with bootstrapping.
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1093 if (m != NULL) {
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1094 if (m->is_static()) {
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1095 // NoSuchMethodException doesn't actually work because it tries to run the
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1096 // <init> function before java_lang_Class is linked. Print error and exit.
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1097 tty->print_cr("ProtectionDomain.impliesCreateAccessControlContext() has the wrong linkage");
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1098 return false; // initialization failed
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1099 }
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1100 Universe::_pd_implies_cache->init(
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1101 SystemDictionary::ProtectionDomain_klass(), m);;
11010 b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1102 }
b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1103
0 a61af66fc99e Initial load duke parents: diff changeset	1104 // The folowing is initializing converter functions for serialization in
a61af66fc99e Initial load duke parents: diff changeset	1105 // JVM.cpp. If we clean up the StrictMath code above we may want to find
a61af66fc99e Initial load duke parents: diff changeset	1106 // a better solution for this as well.
a61af66fc99e Initial load duke parents: diff changeset	1107 initialize_converter_functions();
a61af66fc99e Initial load duke parents: diff changeset	1108
a61af66fc99e Initial load duke parents: diff changeset	1109 // This needs to be done before the first scavenge/gc, since
a61af66fc99e Initial load duke parents: diff changeset	1110 // it's an input to soft ref clearing policy.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1111 {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1112 MutexLocker x(Heap_lock);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1113 Universe::update_heap_info_at_gc();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1114 }
0 a61af66fc99e Initial load duke parents: diff changeset	1115
a61af66fc99e Initial load duke parents: diff changeset	1116 // ("weak") refs processing infrastructure initialization
a61af66fc99e Initial load duke parents: diff changeset	1117 Universe::heap()->post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	1118
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1119 // Initialize performance counters for metaspaces
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1120 MetaspaceCounters::initialize_performance_counters();
12063 1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	1121 CompressedClassSpaceCounters::initialize_performance_counters();
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	1122
11039 71963b3f802a 8013590: NPG: Add a memory pool MXBean for Metaspace ehelin parents: 10973 diff changeset	1123 MemoryService::add_metaspace_memory_pools();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1124
0 a61af66fc99e Initial load duke parents: diff changeset	1125 GC_locker::unlock(); // allow gc after bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	1126
a61af66fc99e Initial load duke parents: diff changeset	1127 MemoryService::set_universe_heap(Universe::_collectedHeap);
a61af66fc99e Initial load duke parents: diff changeset	1128 return true;
a61af66fc99e Initial load duke parents: diff changeset	1129 }
a61af66fc99e Initial load duke parents: diff changeset	1130
a61af66fc99e Initial load duke parents: diff changeset	1131
a61af66fc99e Initial load duke parents: diff changeset	1132 void Universe::compute_base_vtable_size() {
a61af66fc99e Initial load duke parents: diff changeset	1133 _base_vtable_size = ClassLoader::compute_Object_vtable();
a61af66fc99e Initial load duke parents: diff changeset	1134 }
a61af66fc99e Initial load duke parents: diff changeset	1135
a61af66fc99e Initial load duke parents: diff changeset	1136
a61af66fc99e Initial load duke parents: diff changeset	1137 // %%% The Universe::flush_foo methods belong in CodeCache.
a61af66fc99e Initial load duke parents: diff changeset	1138
a61af66fc99e Initial load duke parents: diff changeset	1139 // Flushes compiled methods dependent on dependee.
a61af66fc99e Initial load duke parents: diff changeset	1140 void Universe::flush_dependents_on(instanceKlassHandle dependee) {
a61af66fc99e Initial load duke parents: diff changeset	1141 assert_lock_strong(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	1142
a61af66fc99e Initial load duke parents: diff changeset	1143 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	1144
a61af66fc99e Initial load duke parents: diff changeset	1145 // CodeCache can only be updated by a thread_in_VM and they will all be
a61af66fc99e Initial load duke parents: diff changeset	1146 // stopped dring the safepoint so CodeCache will be safe to update without
a61af66fc99e Initial load duke parents: diff changeset	1147 // holding the CodeCache_lock.
a61af66fc99e Initial load duke parents: diff changeset	1148
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1149 KlassDepChange changes(dependee);
0 a61af66fc99e Initial load duke parents: diff changeset	1150
a61af66fc99e Initial load duke parents: diff changeset	1151 // Compute the dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	1152 if (CodeCache::mark_for_deoptimization(changes) > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1153 // At least one nmethod has been marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	1154 VM_Deoptimize op;
a61af66fc99e Initial load duke parents: diff changeset	1155 VMThread::execute(&op);
a61af66fc99e Initial load duke parents: diff changeset	1156 }
a61af66fc99e Initial load duke parents: diff changeset	1157 }
a61af66fc99e Initial load duke parents: diff changeset	1158
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1159 // Flushes compiled methods dependent on a particular CallSite
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1160 // instance when its target is different than the given MethodHandle.
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1161 void Universe::flush_dependents_on(Handle call_site, Handle method_handle) {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1162 assert_lock_strong(Compile_lock);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1163
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1164 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1165
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1166 // CodeCache can only be updated by a thread_in_VM and they will all be
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1167 // stopped dring the safepoint so CodeCache will be safe to update without
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1168 // holding the CodeCache_lock.
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1169
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1170 CallSiteDepChange changes(call_site(), method_handle());
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1171
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1172 // Compute the dependent nmethods that have a reference to a
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1173 // CallSite object. We use InstanceKlass::mark_dependent_nmethod
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1174 // directly instead of CodeCache::mark_for_deoptimization because we
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	1175 // want dependents on the call site class only not all classes in
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	1176 // the ContextStream.
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1177 int marked = 0;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1178 {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1179 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1180 InstanceKlass* call_site_klass = InstanceKlass::cast(call_site->klass());
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1181 marked = call_site_klass->mark_dependent_nmethods(changes);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1182 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1183 if (marked > 0) {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1184 // At least one nmethod has been marked for deoptimization
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1185 VM_Deoptimize op;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1186 VMThread::execute(&op);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1187 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1188 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	1189
0 a61af66fc99e Initial load duke parents: diff changeset	1190 #ifdef HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	1191 // Flushes compiled methods dependent on dependee in the evolutionary sense
a61af66fc99e Initial load duke parents: diff changeset	1192 void Universe::flush_evol_dependents_on(instanceKlassHandle ev_k_h) {
a61af66fc99e Initial load duke parents: diff changeset	1193 // --- Compile_lock is not held. However we are at a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	1194 assert_locked_or_safepoint(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	1195 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	1196
a61af66fc99e Initial load duke parents: diff changeset	1197 // CodeCache can only be updated by a thread_in_VM and they will all be
a61af66fc99e Initial load duke parents: diff changeset	1198 // stopped dring the safepoint so CodeCache will be safe to update without
a61af66fc99e Initial load duke parents: diff changeset	1199 // holding the CodeCache_lock.
a61af66fc99e Initial load duke parents: diff changeset	1200
a61af66fc99e Initial load duke parents: diff changeset	1201 // Compute the dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	1202 if (CodeCache::mark_for_evol_deoptimization(ev_k_h) > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1203 // At least one nmethod has been marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	1204
a61af66fc99e Initial load duke parents: diff changeset	1205 // All this already happens inside a VM_Operation, so we'll do all the work here.
a61af66fc99e Initial load duke parents: diff changeset	1206 // Stuff copied from VM_Deoptimize and modified slightly.
a61af66fc99e Initial load duke parents: diff changeset	1207
a61af66fc99e Initial load duke parents: diff changeset	1208 // We do not want any GCs to happen while we are in the middle of this VM operation
a61af66fc99e Initial load duke parents: diff changeset	1209 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1210 DeoptimizationMarker dm;
a61af66fc99e Initial load duke parents: diff changeset	1211
a61af66fc99e Initial load duke parents: diff changeset	1212 // Deoptimize all activations depending on marked nmethods
a61af66fc99e Initial load duke parents: diff changeset	1213 Deoptimization::deoptimize_dependents();
a61af66fc99e Initial load duke parents: diff changeset	1214
a61af66fc99e Initial load duke parents: diff changeset	1215 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies)
a61af66fc99e Initial load duke parents: diff changeset	1216 CodeCache::make_marked_nmethods_not_entrant();
a61af66fc99e Initial load duke parents: diff changeset	1217 }
a61af66fc99e Initial load duke parents: diff changeset	1218 }
a61af66fc99e Initial load duke parents: diff changeset	1219 #endif // HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	1220
a61af66fc99e Initial load duke parents: diff changeset	1221
a61af66fc99e Initial load duke parents: diff changeset	1222 // Flushes compiled methods dependent on dependee
a61af66fc99e Initial load duke parents: diff changeset	1223 void Universe::flush_dependents_on_method(methodHandle m_h) {
a61af66fc99e Initial load duke parents: diff changeset	1224 // --- Compile_lock is not held. However we are at a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	1225 assert_locked_or_safepoint(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	1226
a61af66fc99e Initial load duke parents: diff changeset	1227 // CodeCache can only be updated by a thread_in_VM and they will all be
a61af66fc99e Initial load duke parents: diff changeset	1228 // stopped dring the safepoint so CodeCache will be safe to update without
a61af66fc99e Initial load duke parents: diff changeset	1229 // holding the CodeCache_lock.
a61af66fc99e Initial load duke parents: diff changeset	1230
a61af66fc99e Initial load duke parents: diff changeset	1231 // Compute the dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	1232 if (CodeCache::mark_for_deoptimization(m_h()) > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1233 // At least one nmethod has been marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	1234
a61af66fc99e Initial load duke parents: diff changeset	1235 // All this already happens inside a VM_Operation, so we'll do all the work here.
a61af66fc99e Initial load duke parents: diff changeset	1236 // Stuff copied from VM_Deoptimize and modified slightly.
a61af66fc99e Initial load duke parents: diff changeset	1237
a61af66fc99e Initial load duke parents: diff changeset	1238 // We do not want any GCs to happen while we are in the middle of this VM operation
a61af66fc99e Initial load duke parents: diff changeset	1239 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1240 DeoptimizationMarker dm;
a61af66fc99e Initial load duke parents: diff changeset	1241
a61af66fc99e Initial load duke parents: diff changeset	1242 // Deoptimize all activations depending on marked nmethods
a61af66fc99e Initial load duke parents: diff changeset	1243 Deoptimization::deoptimize_dependents();
a61af66fc99e Initial load duke parents: diff changeset	1244
a61af66fc99e Initial load duke parents: diff changeset	1245 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies)
a61af66fc99e Initial load duke parents: diff changeset	1246 CodeCache::make_marked_nmethods_not_entrant();
a61af66fc99e Initial load duke parents: diff changeset	1247 }
a61af66fc99e Initial load duke parents: diff changeset	1248 }
a61af66fc99e Initial load duke parents: diff changeset	1249
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1250 void Universe::print() {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1251 print_on(gclog_or_tty);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1252 }
0 a61af66fc99e Initial load duke parents: diff changeset	1253
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1254 void Universe::print_on(outputStream* st, bool extended) {
0 a61af66fc99e Initial load duke parents: diff changeset	1255 st->print_cr("Heap");
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1256 if (!extended) {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1257 heap()->print_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1258 } else {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1259 heap()->print_extended_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1260 }
0 a61af66fc99e Initial load duke parents: diff changeset	1261 }
a61af66fc99e Initial load duke parents: diff changeset	1262
a61af66fc99e Initial load duke parents: diff changeset	1263 void Universe::print_heap_at_SIGBREAK() {
a61af66fc99e Initial load duke parents: diff changeset	1264 if (PrintHeapAtSIGBREAK) {
a61af66fc99e Initial load duke parents: diff changeset	1265 MutexLocker hl(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	1266 print_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	1267 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1268 tty->flush();
a61af66fc99e Initial load duke parents: diff changeset	1269 }
a61af66fc99e Initial load duke parents: diff changeset	1270 }
a61af66fc99e Initial load duke parents: diff changeset	1271
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	1272 void Universe::print_heap_before_gc(outputStream* st, bool ignore_extended) {
0 a61af66fc99e Initial load duke parents: diff changeset	1273 st->print_cr("{Heap before GC invocations=%u (full %u):",
a61af66fc99e Initial load duke parents: diff changeset	1274 heap()->total_collections(),
a61af66fc99e Initial load duke parents: diff changeset	1275 heap()->total_full_collections());
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	1276 if (!PrintHeapAtGCExtended \|\| ignore_extended) {
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1277 heap()->print_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1278 } else {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1279 heap()->print_extended_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1280 }
0 a61af66fc99e Initial load duke parents: diff changeset	1281 }
a61af66fc99e Initial load duke parents: diff changeset	1282
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	1283 void Universe::print_heap_after_gc(outputStream* st, bool ignore_extended) {
0 a61af66fc99e Initial load duke parents: diff changeset	1284 st->print_cr("Heap after GC invocations=%u (full %u):",
a61af66fc99e Initial load duke parents: diff changeset	1285 heap()->total_collections(),
a61af66fc99e Initial load duke parents: diff changeset	1286 heap()->total_full_collections());
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	1287 if (!PrintHeapAtGCExtended \|\| ignore_extended) {
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1288 heap()->print_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1289 } else {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1290 heap()->print_extended_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4013 diff changeset	1291 }
0 a61af66fc99e Initial load duke parents: diff changeset	1292 st->print_cr("}");
a61af66fc99e Initial load duke parents: diff changeset	1293 }
a61af66fc99e Initial load duke parents: diff changeset	1294
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 9062 diff changeset	1295 void Universe::verify(VerifyOption option, const char* prefix, bool silent) {
0 a61af66fc99e Initial load duke parents: diff changeset	1296 // The use of _verify_in_progress is a temporary work around for
a61af66fc99e Initial load duke parents: diff changeset	1297 // 6320749. Don't bother with a creating a class to set and clear
a61af66fc99e Initial load duke parents: diff changeset	1298 // it since it is only used in this method and the control flow is
a61af66fc99e Initial load duke parents: diff changeset	1299 // straight forward.
a61af66fc99e Initial load duke parents: diff changeset	1300 _verify_in_progress = true;
a61af66fc99e Initial load duke parents: diff changeset	1301
a61af66fc99e Initial load duke parents: diff changeset	1302 COMPILER2_PRESENT(
a61af66fc99e Initial load duke parents: diff changeset	1303 assert(!DerivedPointerTable::is_active(),
a61af66fc99e Initial load duke parents: diff changeset	1304 "DPT should not be active during verification "
a61af66fc99e Initial load duke parents: diff changeset	1305 "(of thread stacks below)");
a61af66fc99e Initial load duke parents: diff changeset	1306 )
a61af66fc99e Initial load duke parents: diff changeset	1307
a61af66fc99e Initial load duke parents: diff changeset	1308 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1309 HandleMark hm; // Handles created during verification can be zapped
a61af66fc99e Initial load duke parents: diff changeset	1310 _verify_count++;
a61af66fc99e Initial load duke parents: diff changeset	1311
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 9062 diff changeset	1312 if (!silent) gclog_or_tty->print(prefix);
0 a61af66fc99e Initial load duke parents: diff changeset	1313 if (!silent) gclog_or_tty->print("[Verifying ");
a61af66fc99e Initial load duke parents: diff changeset	1314 if (!silent) gclog_or_tty->print("threads ");
a61af66fc99e Initial load duke parents: diff changeset	1315 Threads::verify();
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 9062 diff changeset	1316 if (!silent) gclog_or_tty->print("heap ");
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 4944 diff changeset	1317 heap()->verify(silent, option);
0 a61af66fc99e Initial load duke parents: diff changeset	1318 if (!silent) gclog_or_tty->print("syms ");
a61af66fc99e Initial load duke parents: diff changeset	1319 SymbolTable::verify();
a61af66fc99e Initial load duke parents: diff changeset	1320 if (!silent) gclog_or_tty->print("strs ");
a61af66fc99e Initial load duke parents: diff changeset	1321 StringTable::verify();
a61af66fc99e Initial load duke parents: diff changeset	1322 {
a61af66fc99e Initial load duke parents: diff changeset	1323 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	1324 if (!silent) gclog_or_tty->print("zone ");
a61af66fc99e Initial load duke parents: diff changeset	1325 CodeCache::verify();
a61af66fc99e Initial load duke parents: diff changeset	1326 }
a61af66fc99e Initial load duke parents: diff changeset	1327 if (!silent) gclog_or_tty->print("dict ");
a61af66fc99e Initial load duke parents: diff changeset	1328 SystemDictionary::verify();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1329 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1330 if (!silent) gclog_or_tty->print("cldg ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1331 ClassLoaderDataGraph::verify();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1332 #endif
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6870 diff changeset	1333 if (!silent) gclog_or_tty->print("metaspace chunks ");
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6870 diff changeset	1334 MetaspaceAux::verify_free_chunks();
0 a61af66fc99e Initial load duke parents: diff changeset	1335 if (!silent) gclog_or_tty->print("hand ");
a61af66fc99e Initial load duke parents: diff changeset	1336 JNIHandles::verify();
a61af66fc99e Initial load duke parents: diff changeset	1337 if (!silent) gclog_or_tty->print("C-heap ");
a61af66fc99e Initial load duke parents: diff changeset	1338 os::check_heap();
2375 d673ef06fe96 7028374: race in fix_oop_relocations for scavengeable nmethods never parents: 2177 diff changeset	1339 if (!silent) gclog_or_tty->print("code cache ");
d673ef06fe96 7028374: race in fix_oop_relocations for scavengeable nmethods never parents: 2177 diff changeset	1340 CodeCache::verify_oops();
0 a61af66fc99e Initial load duke parents: diff changeset	1341 if (!silent) gclog_or_tty->print_cr("]");
a61af66fc99e Initial load duke parents: diff changeset	1342
a61af66fc99e Initial load duke parents: diff changeset	1343 _verify_in_progress = false;
a61af66fc99e Initial load duke parents: diff changeset	1344 }
a61af66fc99e Initial load duke parents: diff changeset	1345
a61af66fc99e Initial load duke parents: diff changeset	1346 // Oop verification (see MacroAssembler::verify_oop)
a61af66fc99e Initial load duke parents: diff changeset	1347
a61af66fc99e Initial load duke parents: diff changeset	1348 static uintptr_t _verify_oop_data[2] = {0, (uintptr_t)-1};
a61af66fc99e Initial load duke parents: diff changeset	1349 static uintptr_t _verify_klass_data[2] = {0, (uintptr_t)-1};
a61af66fc99e Initial load duke parents: diff changeset	1350
a61af66fc99e Initial load duke parents: diff changeset	1351
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8827 diff changeset	1352 #ifndef PRODUCT
cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8827 diff changeset	1353
0 a61af66fc99e Initial load duke parents: diff changeset	1354 static void calculate_verify_data(uintptr_t verify_data[2],
a61af66fc99e Initial load duke parents: diff changeset	1355 HeapWord* low_boundary,
a61af66fc99e Initial load duke parents: diff changeset	1356 HeapWord* high_boundary) {
a61af66fc99e Initial load duke parents: diff changeset	1357 assert(low_boundary < high_boundary, "bad interval");
a61af66fc99e Initial load duke parents: diff changeset	1358
a61af66fc99e Initial load duke parents: diff changeset	1359 // decide which low-order bits we require to be clear:
a61af66fc99e Initial load duke parents: diff changeset	1360 size_t alignSize = MinObjAlignmentInBytes;
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1507 diff changeset	1361 size_t min_object_size = CollectedHeap::min_fill_size();
0 a61af66fc99e Initial load duke parents: diff changeset	1362
a61af66fc99e Initial load duke parents: diff changeset	1363 // make an inclusive limit:
a61af66fc99e Initial load duke parents: diff changeset	1364 uintptr_t max = (uintptr_t)high_boundary - min_object_size*wordSize;
a61af66fc99e Initial load duke parents: diff changeset	1365 uintptr_t min = (uintptr_t)low_boundary;
a61af66fc99e Initial load duke parents: diff changeset	1366 assert(min < max, "bad interval");
a61af66fc99e Initial load duke parents: diff changeset	1367 uintptr_t diff = max ^ min;
a61af66fc99e Initial load duke parents: diff changeset	1368
a61af66fc99e Initial load duke parents: diff changeset	1369 // throw away enough low-order bits to make the diff vanish
a61af66fc99e Initial load duke parents: diff changeset	1370 uintptr_t mask = (uintptr_t)(-1);
a61af66fc99e Initial load duke parents: diff changeset	1371 while ((mask & diff) != 0)
a61af66fc99e Initial load duke parents: diff changeset	1372 mask <<= 1;
a61af66fc99e Initial load duke parents: diff changeset	1373 uintptr_t bits = (min & mask);
a61af66fc99e Initial load duke parents: diff changeset	1374 assert(bits == (max & mask), "correct mask");
a61af66fc99e Initial load duke parents: diff changeset	1375 // check an intermediate value between min and max, just to make sure:
a61af66fc99e Initial load duke parents: diff changeset	1376 assert(bits == ((min + (max-min)/2) & mask), "correct mask");
a61af66fc99e Initial load duke parents: diff changeset	1377
a61af66fc99e Initial load duke parents: diff changeset	1378 // require address alignment, too:
a61af66fc99e Initial load duke parents: diff changeset	1379 mask \|= (alignSize - 1);
a61af66fc99e Initial load duke parents: diff changeset	1380
a61af66fc99e Initial load duke parents: diff changeset	1381 if (!(verify_data[0] == 0 && verify_data[1] == (uintptr_t)-1)) {
a61af66fc99e Initial load duke parents: diff changeset	1382 assert(verify_data[0] == mask && verify_data[1] == bits, "mask stability");
a61af66fc99e Initial load duke parents: diff changeset	1383 }
a61af66fc99e Initial load duke parents: diff changeset	1384 verify_data[0] = mask;
a61af66fc99e Initial load duke parents: diff changeset	1385 verify_data[1] = bits;
a61af66fc99e Initial load duke parents: diff changeset	1386 }
a61af66fc99e Initial load duke parents: diff changeset	1387
a61af66fc99e Initial load duke parents: diff changeset	1388 // Oop verification (see MacroAssembler::verify_oop)
a61af66fc99e Initial load duke parents: diff changeset	1389
a61af66fc99e Initial load duke parents: diff changeset	1390 uintptr_t Universe::verify_oop_mask() {
a61af66fc99e Initial load duke parents: diff changeset	1391 MemRegion m = heap()->reserved_region();
a61af66fc99e Initial load duke parents: diff changeset	1392 calculate_verify_data(_verify_oop_data,
a61af66fc99e Initial load duke parents: diff changeset	1393 m.start(),
a61af66fc99e Initial load duke parents: diff changeset	1394 m.end());
a61af66fc99e Initial load duke parents: diff changeset	1395 return _verify_oop_data[0];
a61af66fc99e Initial load duke parents: diff changeset	1396 }
a61af66fc99e Initial load duke parents: diff changeset	1397
a61af66fc99e Initial load duke parents: diff changeset	1398
a61af66fc99e Initial load duke parents: diff changeset	1399
a61af66fc99e Initial load duke parents: diff changeset	1400 uintptr_t Universe::verify_oop_bits() {
a61af66fc99e Initial load duke parents: diff changeset	1401 verify_oop_mask();
a61af66fc99e Initial load duke parents: diff changeset	1402 return _verify_oop_data[1];
a61af66fc99e Initial load duke parents: diff changeset	1403 }
a61af66fc99e Initial load duke parents: diff changeset	1404
a61af66fc99e Initial load duke parents: diff changeset	1405 uintptr_t Universe::verify_mark_mask() {
a61af66fc99e Initial load duke parents: diff changeset	1406 return markOopDesc::lock_mask_in_place;
a61af66fc99e Initial load duke parents: diff changeset	1407 }
a61af66fc99e Initial load duke parents: diff changeset	1408
a61af66fc99e Initial load duke parents: diff changeset	1409 uintptr_t Universe::verify_mark_bits() {
a61af66fc99e Initial load duke parents: diff changeset	1410 intptr_t mask = verify_mark_mask();
a61af66fc99e Initial load duke parents: diff changeset	1411 intptr_t bits = (intptr_t)markOopDesc::prototype();
a61af66fc99e Initial load duke parents: diff changeset	1412 assert((bits & ~mask) == 0, "no stray header bits");
a61af66fc99e Initial load duke parents: diff changeset	1413 return bits;
a61af66fc99e Initial load duke parents: diff changeset	1414 }
a61af66fc99e Initial load duke parents: diff changeset	1415 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1416
a61af66fc99e Initial load duke parents: diff changeset	1417
a61af66fc99e Initial load duke parents: diff changeset	1418 void Universe::compute_verify_oop_data() {
a61af66fc99e Initial load duke parents: diff changeset	1419 verify_oop_mask();
a61af66fc99e Initial load duke parents: diff changeset	1420 verify_oop_bits();
a61af66fc99e Initial load duke parents: diff changeset	1421 verify_mark_mask();
a61af66fc99e Initial load duke parents: diff changeset	1422 verify_mark_bits();
a61af66fc99e Initial load duke parents: diff changeset	1423 }
a61af66fc99e Initial load duke parents: diff changeset	1424
a61af66fc99e Initial load duke parents: diff changeset	1425
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1426 void LatestMethodCache::init(Klass* k, Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	1427 if (!UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	1428 _klass = k;
a61af66fc99e Initial load duke parents: diff changeset	1429 }
a61af66fc99e Initial load duke parents: diff changeset	1430 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1431 else {
a61af66fc99e Initial load duke parents: diff changeset	1432 // sharing initilization should have already set up _klass
a61af66fc99e Initial load duke parents: diff changeset	1433 assert(_klass != NULL, "just checking");
a61af66fc99e Initial load duke parents: diff changeset	1434 }
a61af66fc99e Initial load duke parents: diff changeset	1435 #endif
a61af66fc99e Initial load duke parents: diff changeset	1436
a61af66fc99e Initial load duke parents: diff changeset	1437 _method_idnum = m->method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	1438 assert(_method_idnum >= 0, "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1439 }
a61af66fc99e Initial load duke parents: diff changeset	1440
a61af66fc99e Initial load duke parents: diff changeset	1441
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11096 diff changeset	1442 Method* LatestMethodCache::get_method() {
11010 b295e132102d 8001330: Improve on checking order mullan parents: 9062 diff changeset	1443 if (klass() == NULL) return NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1444 InstanceKlass* ik = InstanceKlass::cast(klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	1445 Method* m = ik->method_with_idnum(method_idnum());
0 a61af66fc99e Initial load duke parents: diff changeset	1446 assert(m != NULL, "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1447 return m;
a61af66fc99e Initial load duke parents: diff changeset	1448 }
a61af66fc99e Initial load duke parents: diff changeset	1449
a61af66fc99e Initial load duke parents: diff changeset	1450
a61af66fc99e Initial load duke parents: diff changeset	1451 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1452 // Release dummy object(s) at bottom of heap
a61af66fc99e Initial load duke parents: diff changeset	1453 bool Universe::release_fullgc_alot_dummy() {
a61af66fc99e Initial load duke parents: diff changeset	1454 MutexLocker ml(FullGCALot_lock);
a61af66fc99e Initial load duke parents: diff changeset	1455 if (_fullgc_alot_dummy_array != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1456 if (_fullgc_alot_dummy_next >= _fullgc_alot_dummy_array->length()) {
a61af66fc99e Initial load duke parents: diff changeset	1457 // No more dummies to release, release entire array instead
a61af66fc99e Initial load duke parents: diff changeset	1458 _fullgc_alot_dummy_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1459 return false;
a61af66fc99e Initial load duke parents: diff changeset	1460 }
a61af66fc99e Initial load duke parents: diff changeset	1461 if (!UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	1462 // Release dummy at bottom of old generation
a61af66fc99e Initial load duke parents: diff changeset	1463 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL);
a61af66fc99e Initial load duke parents: diff changeset	1464 }
a61af66fc99e Initial load duke parents: diff changeset	1465 // Release dummy at bottom of permanent generation
a61af66fc99e Initial load duke parents: diff changeset	1466 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL);
a61af66fc99e Initial load duke parents: diff changeset	1467 }
a61af66fc99e Initial load duke parents: diff changeset	1468 return true;
a61af66fc99e Initial load duke parents: diff changeset	1469 }
a61af66fc99e Initial load duke parents: diff changeset	1470
a61af66fc99e Initial load duke parents: diff changeset	1471 #endif // ASSERT

Mercurial > hg > truffle

annotate src/share/vm/memory/universe.cpp @ 12233:40136aa2cdb1