graal-compiler: src/share/vm/memory/universe.cpp annotate

annotate src/share/vm/memory/universe.cpp @ 1721:413ad0331a0c

6977924: Changes for 6975078 produce build error with certain gcc versions Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error. Reviewed-by: jcoomes, ysr, phh

author	johnc
date	Wed, 18 Aug 2010 10:59:06 -0700
parents	e9ff18c4ace7
children	9eecf81a02fb 0ac62b4d6507

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	2 * Copyright (c) 1997, 2009, 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
a61af66fc99e Initial load duke parents: diff changeset	25 # include "incls/_precompiled.incl"
a61af66fc99e Initial load duke parents: diff changeset	26 # include "incls/_universe.cpp.incl"
a61af66fc99e Initial load duke parents: diff changeset	27
a61af66fc99e Initial load duke parents: diff changeset	28 // Known objects
a61af66fc99e Initial load duke parents: diff changeset	29 klassOop Universe::_boolArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	30 klassOop Universe::_byteArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	31 klassOop Universe::_charArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	32 klassOop Universe::_intArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	33 klassOop Universe::_shortArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	34 klassOop Universe::_longArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	35 klassOop Universe::_singleArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	36 klassOop Universe::_doubleArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	37 klassOop Universe::_typeArrayKlassObjs[T_VOID+1] = { NULL /, NULL.../ };
a61af66fc99e Initial load duke parents: diff changeset	38 klassOop Universe::_objectArrayKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	39 klassOop Universe::_symbolKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	40 klassOop Universe::_methodKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	41 klassOop Universe::_constMethodKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	42 klassOop Universe::_methodDataKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	43 klassOop Universe::_klassKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	44 klassOop Universe::_arrayKlassKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	45 klassOop Universe::_objArrayKlassKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	46 klassOop Universe::_typeArrayKlassKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	47 klassOop Universe::_instanceKlassKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	48 klassOop Universe::_constantPoolKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	49 klassOop Universe::_constantPoolCacheKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	50 klassOop Universe::_compiledICHolderKlassObj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	51 klassOop Universe::_systemObjArrayKlassObj = NULL;
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	52 oop Universe::_int_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	53 oop Universe::_float_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	54 oop Universe::_double_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	55 oop Universe::_byte_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	56 oop Universe::_bool_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	57 oop Universe::_char_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	58 oop Universe::_long_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	59 oop Universe::_short_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	60 oop Universe::_void_mirror = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	61 oop Universe::_mirrors[T_VOID+1] = { NULL /, NULL.../ };
0 a61af66fc99e Initial load duke parents: diff changeset	62 oop Universe::_main_thread_group = NULL;
a61af66fc99e Initial load duke parents: diff changeset	63 oop Universe::_system_thread_group = NULL;
a61af66fc99e Initial load duke parents: diff changeset	64 typeArrayOop Universe::_the_empty_byte_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	65 typeArrayOop Universe::_the_empty_short_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	66 typeArrayOop Universe::_the_empty_int_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	67 objArrayOop Universe::_the_empty_system_obj_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	68 objArrayOop Universe::_the_empty_class_klass_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	69 objArrayOop Universe::_the_array_interfaces_array = NULL;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	70 oop Universe::_the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	71 oop Universe::_the_min_jint_string = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	72 LatestMethodOopCache* Universe::_finalizer_register_cache = NULL;
a61af66fc99e Initial load duke parents: diff changeset	73 LatestMethodOopCache* Universe::_loader_addClass_cache = NULL;
a61af66fc99e Initial load duke parents: diff changeset	74 ActiveMethodOopsCache* Universe::_reflect_invoke_cache = NULL;
a61af66fc99e Initial load duke parents: diff changeset	75 oop Universe::_out_of_memory_error_java_heap = NULL;
a61af66fc99e Initial load duke parents: diff changeset	76 oop Universe::_out_of_memory_error_perm_gen = NULL;
a61af66fc99e Initial load duke parents: diff changeset	77 oop Universe::_out_of_memory_error_array_size = NULL;
a61af66fc99e Initial load duke parents: diff changeset	78 oop Universe::_out_of_memory_error_gc_overhead_limit = NULL;
a61af66fc99e Initial load duke parents: diff changeset	79 objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	80 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	81 bool Universe::_verify_in_progress = false;
a61af66fc99e Initial load duke parents: diff changeset	82 oop Universe::_null_ptr_exception_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	83 oop Universe::_arithmetic_exception_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	84 oop Universe::_virtual_machine_error_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	85 oop Universe::_vm_exception = NULL;
a61af66fc99e Initial load duke parents: diff changeset	86 oop Universe::_emptySymbol = NULL;
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 // These variables are guarded by FullGCALot_lock.
a61af66fc99e Initial load duke parents: diff changeset	89 debug_only(objArrayOop Universe::_fullgc_alot_dummy_array = NULL;)
a61af66fc99e Initial load duke parents: diff changeset	90 debug_only(int Universe::_fullgc_alot_dummy_next = 0;)
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 // Heap
a61af66fc99e Initial load duke parents: diff changeset	94 int Universe::_verify_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 int Universe::_base_vtable_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	97 bool Universe::_bootstrapping = false;
a61af66fc99e Initial load duke parents: diff changeset	98 bool Universe::_fully_initialized = false;
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 size_t Universe::_heap_capacity_at_last_gc;
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	101 size_t Universe::_heap_used_at_last_gc = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	102
a61af66fc99e Initial load duke parents: diff changeset	103 CollectedHeap* Universe::_collectedHeap = NULL;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	104
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	105 NarrowOopStruct Universe::_narrow_oop = { NULL, 0, true };
0 a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107
a61af66fc99e Initial load duke parents: diff changeset	108 void Universe::basic_type_classes_do(void f(klassOop)) {
a61af66fc99e Initial load duke parents: diff changeset	109 f(boolArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	110 f(byteArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	111 f(charArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	112 f(intArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	113 f(shortArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	114 f(longArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	115 f(singleArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	116 f(doubleArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	117 }
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120 void Universe::system_classes_do(void f(klassOop)) {
a61af66fc99e Initial load duke parents: diff changeset	121 f(symbolKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	122 f(methodKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	123 f(constMethodKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	124 f(methodDataKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	125 f(klassKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	126 f(arrayKlassKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	127 f(objArrayKlassKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	128 f(typeArrayKlassKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	129 f(instanceKlassKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	130 f(constantPoolKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	131 f(systemObjArrayKlassObj());
a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 void Universe::oops_do(OopClosure* f, bool do_all) {
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 f->do_oop((oop*) &_int_mirror);
a61af66fc99e Initial load duke parents: diff changeset	137 f->do_oop((oop*) &_float_mirror);
a61af66fc99e Initial load duke parents: diff changeset	138 f->do_oop((oop*) &_double_mirror);
a61af66fc99e Initial load duke parents: diff changeset	139 f->do_oop((oop*) &_byte_mirror);
a61af66fc99e Initial load duke parents: diff changeset	140 f->do_oop((oop*) &_bool_mirror);
a61af66fc99e Initial load duke parents: diff changeset	141 f->do_oop((oop*) &_char_mirror);
a61af66fc99e Initial load duke parents: diff changeset	142 f->do_oop((oop*) &_long_mirror);
a61af66fc99e Initial load duke parents: diff changeset	143 f->do_oop((oop*) &_short_mirror);
a61af66fc99e Initial load duke parents: diff changeset	144 f->do_oop((oop*) &_void_mirror);
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 // It's important to iterate over these guys even if they are null,
a61af66fc99e Initial load duke parents: diff changeset	147 // since that's how shared heaps are restored.
a61af66fc99e Initial load duke parents: diff changeset	148 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
a61af66fc99e Initial load duke parents: diff changeset	149 f->do_oop((oop*) &_mirrors[i]);
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151 assert(_mirrors[0] == NULL && _mirrors[T_BOOLEAN - 1] == NULL, "checking");
a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 // %%% Consider moving those "shared oops" over here with the others.
a61af66fc99e Initial load duke parents: diff changeset	154 f->do_oop((oop*)&_boolArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	155 f->do_oop((oop*)&_byteArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	156 f->do_oop((oop*)&_charArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	157 f->do_oop((oop*)&_intArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	158 f->do_oop((oop*)&_shortArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	159 f->do_oop((oop*)&_longArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	160 f->do_oop((oop*)&_singleArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	161 f->do_oop((oop*)&_doubleArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	162 f->do_oop((oop*)&_objectArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	163 {
a61af66fc99e Initial load duke parents: diff changeset	164 for (int i = 0; i < T_VOID+1; i++) {
a61af66fc99e Initial load duke parents: diff changeset	165 if (_typeArrayKlassObjs[i] != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	166 assert(i >= T_BOOLEAN, "checking");
a61af66fc99e Initial load duke parents: diff changeset	167 f->do_oop((oop*)&_typeArrayKlassObjs[i]);
a61af66fc99e Initial load duke parents: diff changeset	168 } else if (do_all) {
a61af66fc99e Initial load duke parents: diff changeset	169 f->do_oop((oop*)&_typeArrayKlassObjs[i]);
a61af66fc99e Initial load duke parents: diff changeset	170 }
a61af66fc99e Initial load duke parents: diff changeset	171 }
a61af66fc99e Initial load duke parents: diff changeset	172 }
a61af66fc99e Initial load duke parents: diff changeset	173 f->do_oop((oop*)&_symbolKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	174 f->do_oop((oop*)&_methodKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	175 f->do_oop((oop*)&_constMethodKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	176 f->do_oop((oop*)&_methodDataKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	177 f->do_oop((oop*)&_klassKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	178 f->do_oop((oop*)&_arrayKlassKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	179 f->do_oop((oop*)&_objArrayKlassKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	180 f->do_oop((oop*)&_typeArrayKlassKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	181 f->do_oop((oop*)&_instanceKlassKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	182 f->do_oop((oop*)&_constantPoolKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	183 f->do_oop((oop*)&_constantPoolCacheKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	184 f->do_oop((oop*)&_compiledICHolderKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	185 f->do_oop((oop*)&_systemObjArrayKlassObj);
a61af66fc99e Initial load duke parents: diff changeset	186 f->do_oop((oop*)&_the_empty_byte_array);
a61af66fc99e Initial load duke parents: diff changeset	187 f->do_oop((oop*)&_the_empty_short_array);
a61af66fc99e Initial load duke parents: diff changeset	188 f->do_oop((oop*)&_the_empty_int_array);
a61af66fc99e Initial load duke parents: diff changeset	189 f->do_oop((oop*)&_the_empty_system_obj_array);
a61af66fc99e Initial load duke parents: diff changeset	190 f->do_oop((oop*)&_the_empty_class_klass_array);
a61af66fc99e Initial load duke parents: diff changeset	191 f->do_oop((oop*)&_the_array_interfaces_array);
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	192 f->do_oop((oop*)&_the_null_string);
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	193 f->do_oop((oop*)&_the_min_jint_string);
0 a61af66fc99e Initial load duke parents: diff changeset	194 _finalizer_register_cache->oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	195 _loader_addClass_cache->oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	196 _reflect_invoke_cache->oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	197 f->do_oop((oop*)&_out_of_memory_error_java_heap);
a61af66fc99e Initial load duke parents: diff changeset	198 f->do_oop((oop*)&_out_of_memory_error_perm_gen);
a61af66fc99e Initial load duke parents: diff changeset	199 f->do_oop((oop*)&_out_of_memory_error_array_size);
a61af66fc99e Initial load duke parents: diff changeset	200 f->do_oop((oop*)&_out_of_memory_error_gc_overhead_limit);
a61af66fc99e Initial load duke parents: diff changeset	201 if (_preallocated_out_of_memory_error_array != (oop)NULL) { // NULL when DumpSharedSpaces
a61af66fc99e Initial load duke parents: diff changeset	202 f->do_oop((oop*)&_preallocated_out_of_memory_error_array);
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204 f->do_oop((oop*)&_null_ptr_exception_instance);
a61af66fc99e Initial load duke parents: diff changeset	205 f->do_oop((oop*)&_arithmetic_exception_instance);
a61af66fc99e Initial load duke parents: diff changeset	206 f->do_oop((oop*)&_virtual_machine_error_instance);
a61af66fc99e Initial load duke parents: diff changeset	207 f->do_oop((oop*)&_main_thread_group);
a61af66fc99e Initial load duke parents: diff changeset	208 f->do_oop((oop*)&_system_thread_group);
a61af66fc99e Initial load duke parents: diff changeset	209 f->do_oop((oop*)&_vm_exception);
a61af66fc99e Initial load duke parents: diff changeset	210 f->do_oop((oop*)&_emptySymbol);
a61af66fc99e Initial load duke parents: diff changeset	211 debug_only(f->do_oop((oop*)&_fullgc_alot_dummy_array);)
a61af66fc99e Initial load duke parents: diff changeset	212 }
a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 void Universe::check_alignment(uintx size, uintx alignment, const char* name) {
a61af66fc99e Initial load duke parents: diff changeset	216 if (size < alignment \|\| size % alignment != 0) {
a61af66fc99e Initial load duke parents: diff changeset	217 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	218 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	219 st.print("Size of %s (%ld bytes) must be aligned to %ld bytes", name, size, alignment);
a61af66fc99e Initial load duke parents: diff changeset	220 char* error = st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	221 vm_exit_during_initialization(error);
a61af66fc99e Initial load duke parents: diff changeset	222 }
a61af66fc99e Initial load duke parents: diff changeset	223 }
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 void Universe::genesis(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	227 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	228 { FlagSetting fs(_bootstrapping, true);
a61af66fc99e Initial load duke parents: diff changeset	229
a61af66fc99e Initial load duke parents: diff changeset	230 { MutexLocker mc(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 // determine base vtable size; without that we cannot create the array klasses
a61af66fc99e Initial load duke parents: diff changeset	233 compute_base_vtable_size();
a61af66fc99e Initial load duke parents: diff changeset	234
a61af66fc99e Initial load duke parents: diff changeset	235 if (!UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	236 _klassKlassObj = klassKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	237 _arrayKlassKlassObj = arrayKlassKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	238
a61af66fc99e Initial load duke parents: diff changeset	239 _objArrayKlassKlassObj = objArrayKlassKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	240 _instanceKlassKlassObj = instanceKlassKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	241 _typeArrayKlassKlassObj = typeArrayKlassKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 _symbolKlassObj = symbolKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 _emptySymbol = oopFactory::new_symbol("", CHECK);
a61af66fc99e Initial load duke parents: diff changeset	246
a61af66fc99e Initial load duke parents: diff changeset	247 _boolArrayKlassObj = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	248 _charArrayKlassObj = typeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	249 _singleArrayKlassObj = typeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	250 _doubleArrayKlassObj = typeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	251 _byteArrayKlassObj = typeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	252 _shortArrayKlassObj = typeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	253 _intArrayKlassObj = typeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	254 _longArrayKlassObj = typeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	257 _typeArrayKlassObjs[T_CHAR] = _charArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	258 _typeArrayKlassObjs[T_FLOAT] = _singleArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	259 _typeArrayKlassObjs[T_DOUBLE] = _doubleArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	260 _typeArrayKlassObjs[T_BYTE] = _byteArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	261 _typeArrayKlassObjs[T_SHORT] = _shortArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	262 _typeArrayKlassObjs[T_INT] = _intArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	263 _typeArrayKlassObjs[T_LONG] = _longArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	264
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	265 _methodKlassObj = methodKlass::create_klass(CHECK);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	266 _constMethodKlassObj = constMethodKlass::create_klass(CHECK);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	267 _methodDataKlassObj = methodDataKlass::create_klass(CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	268 _constantPoolKlassObj = constantPoolKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	269 _constantPoolCacheKlassObj = constantPoolCacheKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	270
a61af66fc99e Initial load duke parents: diff changeset	271 _compiledICHolderKlassObj = compiledICHolderKlass::create_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	272 _systemObjArrayKlassObj = objArrayKlassKlass::cast(objArrayKlassKlassObj())->allocate_system_objArray_klass(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	273
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 453 diff changeset	274 _the_empty_byte_array = oopFactory::new_permanent_byteArray(0, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	275 _the_empty_short_array = oopFactory::new_permanent_shortArray(0, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	276 _the_empty_int_array = oopFactory::new_permanent_intArray(0, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	277 _the_empty_system_obj_array = oopFactory::new_system_objArray(0, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 _the_array_interfaces_array = oopFactory::new_system_objArray(2, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	280 _vm_exception = oopFactory::new_symbol("vm exception holder", CHECK);
a61af66fc99e Initial load duke parents: diff changeset	281 } else {
a61af66fc99e Initial load duke parents: diff changeset	282 FileMapInfo *mapinfo = FileMapInfo::current_info();
a61af66fc99e Initial load duke parents: diff changeset	283 char* buffer = mapinfo->region_base(CompactingPermGenGen::md);
a61af66fc99e Initial load duke parents: diff changeset	284 void vtbl_list = (void)buffer;
a61af66fc99e Initial load duke parents: diff changeset	285 init_self_patching_vtbl_list(vtbl_list,
a61af66fc99e Initial load duke parents: diff changeset	286 CompactingPermGenGen::vtbl_list_size);
a61af66fc99e Initial load duke parents: diff changeset	287 }
a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 vmSymbols::initialize(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 SystemDictionary::initialize(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	293
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	294 klassOop ok = SystemDictionary::Object_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	295
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	296 _the_null_string = StringTable::intern("null", CHECK);
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	297 _the_min_jint_string = StringTable::intern("-2147483648", CHECK);
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1057 diff changeset	298
0 a61af66fc99e Initial load duke parents: diff changeset	299 if (UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	300 // Verify shared interfaces array.
a61af66fc99e Initial load duke parents: diff changeset	301 assert(_the_array_interfaces_array->obj_at(0) ==
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	302 SystemDictionary::Cloneable_klass(), "u3");
0 a61af66fc99e Initial load duke parents: diff changeset	303 assert(_the_array_interfaces_array->obj_at(1) ==
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	304 SystemDictionary::Serializable_klass(), "u3");
0 a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306 // Verify element klass for system obj array klass
a61af66fc99e Initial load duke parents: diff changeset	307 assert(objArrayKlass::cast(_systemObjArrayKlassObj)->element_klass() == ok, "u1");
a61af66fc99e Initial load duke parents: diff changeset	308 assert(objArrayKlass::cast(_systemObjArrayKlassObj)->bottom_klass() == ok, "u2");
a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 // Verify super class for the classes created above
a61af66fc99e Initial load duke parents: diff changeset	311 assert(Klass::cast(boolArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	312 assert(Klass::cast(charArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	313 assert(Klass::cast(singleArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	314 assert(Klass::cast(doubleArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	315 assert(Klass::cast(byteArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	316 assert(Klass::cast(shortArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	317 assert(Klass::cast(intArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	318 assert(Klass::cast(longArrayKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	319 assert(Klass::cast(constantPoolKlassObj() )->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	320 assert(Klass::cast(systemObjArrayKlassObj())->super() == ok, "u3");
a61af66fc99e Initial load duke parents: diff changeset	321 } else {
a61af66fc99e Initial load duke parents: diff changeset	322 // Set up shared interfaces array. (Do this before supers are set up.)
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	323 _the_array_interfaces_array->obj_at_put(0, SystemDictionary::Cloneable_klass());
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	324 _the_array_interfaces_array->obj_at_put(1, SystemDictionary::Serializable_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 // Set element klass for system obj array klass
a61af66fc99e Initial load duke parents: diff changeset	327 objArrayKlass::cast(_systemObjArrayKlassObj)->set_element_klass(ok);
a61af66fc99e Initial load duke parents: diff changeset	328 objArrayKlass::cast(_systemObjArrayKlassObj)->set_bottom_klass(ok);
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 // Set super class for the classes created above
a61af66fc99e Initial load duke parents: diff changeset	331 Klass::cast(boolArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	332 Klass::cast(charArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	333 Klass::cast(singleArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	334 Klass::cast(doubleArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	335 Klass::cast(byteArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	336 Klass::cast(shortArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	337 Klass::cast(intArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	338 Klass::cast(longArrayKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	339 Klass::cast(constantPoolKlassObj() )->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	340 Klass::cast(systemObjArrayKlassObj())->initialize_supers(ok, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	341 Klass::cast(boolArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	342 Klass::cast(charArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	343 Klass::cast(singleArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	344 Klass::cast(doubleArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	345 Klass::cast(byteArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	346 Klass::cast(shortArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	347 Klass::cast(intArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	348 Klass::cast(longArrayKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	349 Klass::cast(constantPoolKlassObj() )->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	350 Klass::cast(systemObjArrayKlassObj())->set_super(ok);
a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 Klass::cast(boolArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	354 Klass::cast(charArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	355 Klass::cast(singleArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	356 Klass::cast(doubleArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	357 Klass::cast(byteArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	358 Klass::cast(shortArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	359 Klass::cast(intArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	360 Klass::cast(longArrayKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	361 Klass::cast(constantPoolKlassObj() )->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	362 Klass::cast(systemObjArrayKlassObj())->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	363 } // end of core bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	364
a61af66fc99e Initial load duke parents: diff changeset	365 // Initialize _objectArrayKlass after core bootstraping to make
a61af66fc99e Initial load duke parents: diff changeset	366 // sure the super class is set up properly for _objectArrayKlass.
a61af66fc99e Initial load duke parents: diff changeset	367 _objectArrayKlassObj = instanceKlass::
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	368 cast(SystemDictionary::Object_klass())->array_klass(1, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	369 // Add the class to the class hierarchy manually to make sure that
a61af66fc99e Initial load duke parents: diff changeset	370 // its vtable is initialized after core bootstrapping is completed.
a61af66fc99e Initial load duke parents: diff changeset	371 Klass::cast(_objectArrayKlassObj)->append_to_sibling_list();
a61af66fc99e Initial load duke parents: diff changeset	372
a61af66fc99e Initial load duke parents: diff changeset	373 // Compute is_jdk version flags.
a61af66fc99e Initial load duke parents: diff changeset	374 // Only 1.3 or later has the java.lang.Shutdown class.
a61af66fc99e Initial load duke parents: diff changeset	375 // Only 1.4 or later has the java.lang.CharSequence interface.
a61af66fc99e Initial load duke parents: diff changeset	376 // 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	377 if (JDK_Version::is_partially_initialized()) {
d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	378 uint8_t jdk_version;
d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	379 klassOop k = SystemDictionary::resolve_or_null(
d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	380 vmSymbolHandles::java_lang_management_MemoryUsage(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	381 CLEAR_PENDING_EXCEPTION; // ignore exceptions
a61af66fc99e Initial load duke parents: diff changeset	382 if (k == NULL) {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	383 k = SystemDictionary::resolve_or_null(
d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	384 vmSymbolHandles::java_lang_CharSequence(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	385 CLEAR_PENDING_EXCEPTION; // ignore exceptions
a61af66fc99e Initial load duke parents: diff changeset	386 if (k == NULL) {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	387 k = SystemDictionary::resolve_or_null(
d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	388 vmSymbolHandles::java_lang_Shutdown(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	389 CLEAR_PENDING_EXCEPTION; // ignore exceptions
a61af66fc99e Initial load duke parents: diff changeset	390 if (k == NULL) {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	391 jdk_version = 2;
0 a61af66fc99e Initial load duke parents: diff changeset	392 } else {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	393 jdk_version = 3;
0 a61af66fc99e Initial load duke parents: diff changeset	394 }
a61af66fc99e Initial load duke parents: diff changeset	395 } else {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	396 jdk_version = 4;
0 a61af66fc99e Initial load duke parents: diff changeset	397 }
a61af66fc99e Initial load duke parents: diff changeset	398 } else {
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	399 jdk_version = 5;
0 a61af66fc99e Initial load duke parents: diff changeset	400 }
242 d95b224e9f17 6721093: -XX:AppendRatio=N not supported kamg parents: 196 diff changeset	401 JDK_Version::fully_initialize(jdk_version);
0 a61af66fc99e Initial load duke parents: diff changeset	402 }
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	405 if (FullGCALot) {
a61af66fc99e Initial load duke parents: diff changeset	406 // Allocate an array of dummy objects.
a61af66fc99e Initial load duke parents: diff changeset	407 // We'd like these to be at the bottom of the old generation,
a61af66fc99e Initial load duke parents: diff changeset	408 // so that when we free one and then collect,
a61af66fc99e Initial load duke parents: diff changeset	409 // (almost) the whole heap moves
a61af66fc99e Initial load duke parents: diff changeset	410 // and we find out if we actually update all the oops correctly.
a61af66fc99e Initial load duke parents: diff changeset	411 // But we can't allocate directly in the old generation,
a61af66fc99e Initial load duke parents: diff changeset	412 // so we allocate wherever, and hope that the first collection
a61af66fc99e Initial load duke parents: diff changeset	413 // moves these objects to the bottom of the old generation.
a61af66fc99e Initial load duke parents: diff changeset	414 // We can allocate directly in the permanent generation, so we do.
a61af66fc99e Initial load duke parents: diff changeset	415 int size;
a61af66fc99e Initial load duke parents: diff changeset	416 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	417 warning("Using +FullGCALot with concurrent mark sweep gc "
a61af66fc99e Initial load duke parents: diff changeset	418 "will not force all objects to relocate");
a61af66fc99e Initial load duke parents: diff changeset	419 size = FullGCALotDummies;
a61af66fc99e Initial load duke parents: diff changeset	420 } else {
a61af66fc99e Initial load duke parents: diff changeset	421 size = FullGCALotDummies * 2;
a61af66fc99e Initial load duke parents: diff changeset	422 }
a61af66fc99e Initial load duke parents: diff changeset	423 objArrayOop naked_array = oopFactory::new_system_objArray(size, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	424 objArrayHandle dummy_array(THREAD, naked_array);
a61af66fc99e Initial load duke parents: diff changeset	425 int i = 0;
a61af66fc99e Initial load duke parents: diff changeset	426 while (i < size) {
a61af66fc99e Initial load duke parents: diff changeset	427 if (!UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	428 // Allocate dummy in old generation
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	429 oop dummy = instanceKlass::cast(SystemDictionary::Object_klass())->allocate_instance(CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	430 dummy_array->obj_at_put(i++, dummy);
a61af66fc99e Initial load duke parents: diff changeset	431 }
a61af66fc99e Initial load duke parents: diff changeset	432 // Allocate dummy in permanent generation
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	433 oop dummy = instanceKlass::cast(SystemDictionary::Object_klass())->allocate_permanent_instance(CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	434 dummy_array->obj_at_put(i++, dummy);
a61af66fc99e Initial load duke parents: diff changeset	435 }
a61af66fc99e Initial load duke parents: diff changeset	436 {
a61af66fc99e Initial load duke parents: diff changeset	437 // Only modify the global variable inside the mutex.
a61af66fc99e Initial load duke parents: diff changeset	438 // If we had a race to here, the other dummy_array instances
a61af66fc99e Initial load duke parents: diff changeset	439 // and their elements just get dropped on the floor, which is fine.
a61af66fc99e Initial load duke parents: diff changeset	440 MutexLocker ml(FullGCALot_lock);
a61af66fc99e Initial load duke parents: diff changeset	441 if (_fullgc_alot_dummy_array == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	442 _fullgc_alot_dummy_array = dummy_array();
a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445 assert(i == _fullgc_alot_dummy_array->length(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	446 }
a61af66fc99e Initial load duke parents: diff changeset	447 #endif
a61af66fc99e Initial load duke parents: diff changeset	448 }
a61af66fc99e Initial load duke parents: diff changeset	449
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 static inline void add_vtable(void** list, int* n, Klass* o, int count) {
a61af66fc99e Initial load duke parents: diff changeset	452 list[(n)++] = (void**)&o->vtbl_value();
a61af66fc99e Initial load duke parents: diff changeset	453 guarantee((*n) <= count, "vtable list too small.");
a61af66fc99e Initial load duke parents: diff changeset	454 }
a61af66fc99e Initial load duke parents: diff changeset	455
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 void Universe::init_self_patching_vtbl_list(void** list, int count) {
a61af66fc99e Initial load duke parents: diff changeset	458 int n = 0;
a61af66fc99e Initial load duke parents: diff changeset	459 { klassKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	460 { arrayKlassKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	461 { objArrayKlassKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	462 { instanceKlassKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	463 { instanceKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	464 { instanceRefKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	465 { typeArrayKlassKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	466 { symbolKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	467 { typeArrayKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	468 { methodKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	469 { constMethodKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	470 { constantPoolKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	471 { constantPoolCacheKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	472 { objArrayKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	473 { methodDataKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	474 { compiledICHolderKlass o; add_vtable(list, &n, &o, count); }
a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476
a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 class FixupMirrorClosure: public ObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	479 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	480 virtual void do_object(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	481 if (obj->is_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	482 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	483 KlassHandle k(THREAD, klassOop(obj));
a61af66fc99e Initial load duke parents: diff changeset	484 // We will never reach the CATCH below since Exceptions::_throw will cause
a61af66fc99e Initial load duke parents: diff changeset	485 // the VM to exit if an exception is thrown during initialization
a61af66fc99e Initial load duke parents: diff changeset	486 java_lang_Class::create_mirror(k, CATCH);
a61af66fc99e Initial load duke parents: diff changeset	487 // This call unconditionally creates a new mirror for k,
a61af66fc99e Initial load duke parents: diff changeset	488 // and links in k's component_mirror field if k is an array.
a61af66fc99e Initial load duke parents: diff changeset	489 // If k is an objArray, k's element type must already have
a61af66fc99e Initial load duke parents: diff changeset	490 // a mirror. In other words, this closure must process
a61af66fc99e Initial load duke parents: diff changeset	491 // the component type of an objArray k before it processes k.
a61af66fc99e Initial load duke parents: diff changeset	492 // This works because the permgen iterator presents arrays
a61af66fc99e Initial load duke parents: diff changeset	493 // and their component types in order of creation.
a61af66fc99e Initial load duke parents: diff changeset	494 }
a61af66fc99e Initial load duke parents: diff changeset	495 }
a61af66fc99e Initial load duke parents: diff changeset	496 };
a61af66fc99e Initial load duke parents: diff changeset	497
a61af66fc99e Initial load duke parents: diff changeset	498 void Universe::initialize_basic_type_mirrors(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	499 if (UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	500 assert(_int_mirror != NULL, "already loaded");
a61af66fc99e Initial load duke parents: diff changeset	501 assert(_void_mirror == _mirrors[T_VOID], "consistently loaded");
a61af66fc99e Initial load duke parents: diff changeset	502 } else {
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 assert(_int_mirror==NULL, "basic type mirrors already initialized");
a61af66fc99e Initial load duke parents: diff changeset	505 _int_mirror =
a61af66fc99e Initial load duke parents: diff changeset	506 java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	507 _float_mirror =
a61af66fc99e Initial load duke parents: diff changeset	508 java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	509 _double_mirror =
a61af66fc99e Initial load duke parents: diff changeset	510 java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	511 _byte_mirror =
a61af66fc99e Initial load duke parents: diff changeset	512 java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	513 _bool_mirror =
a61af66fc99e Initial load duke parents: diff changeset	514 java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	515 _char_mirror =
a61af66fc99e Initial load duke parents: diff changeset	516 java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	517 _long_mirror =
a61af66fc99e Initial load duke parents: diff changeset	518 java_lang_Class::create_basic_type_mirror("long", T_LONG, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	519 _short_mirror =
a61af66fc99e Initial load duke parents: diff changeset	520 java_lang_Class::create_basic_type_mirror("short", T_SHORT, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	521 _void_mirror =
a61af66fc99e Initial load duke parents: diff changeset	522 java_lang_Class::create_basic_type_mirror("void", T_VOID, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	523
a61af66fc99e Initial load duke parents: diff changeset	524 _mirrors[T_INT] = _int_mirror;
a61af66fc99e Initial load duke parents: diff changeset	525 _mirrors[T_FLOAT] = _float_mirror;
a61af66fc99e Initial load duke parents: diff changeset	526 _mirrors[T_DOUBLE] = _double_mirror;
a61af66fc99e Initial load duke parents: diff changeset	527 _mirrors[T_BYTE] = _byte_mirror;
a61af66fc99e Initial load duke parents: diff changeset	528 _mirrors[T_BOOLEAN] = _bool_mirror;
a61af66fc99e Initial load duke parents: diff changeset	529 _mirrors[T_CHAR] = _char_mirror;
a61af66fc99e Initial load duke parents: diff changeset	530 _mirrors[T_LONG] = _long_mirror;
a61af66fc99e Initial load duke parents: diff changeset	531 _mirrors[T_SHORT] = _short_mirror;
a61af66fc99e Initial load duke parents: diff changeset	532 _mirrors[T_VOID] = _void_mirror;
a61af66fc99e Initial load duke parents: diff changeset	533 //_mirrors[T_OBJECT] = instanceKlass::cast(_object_klass)->java_mirror();
a61af66fc99e Initial load duke parents: diff changeset	534 //_mirrors[T_ARRAY] = instanceKlass::cast(_object_klass)->java_mirror();
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 void Universe::fixup_mirrors(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	539 // Bootstrap problem: all classes gets a mirror (java.lang.Class instance) assigned eagerly,
a61af66fc99e Initial load duke parents: diff changeset	540 // but we cannot do that for classes created before java.lang.Class is loaded. Here we simply
a61af66fc99e Initial load duke parents: diff changeset	541 // walk over permanent objects created so far (mostly classes) and fixup their mirrors. Note
a61af66fc99e Initial load duke parents: diff changeset	542 // 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	543 assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded");
0 a61af66fc99e Initial load duke parents: diff changeset	544 FixupMirrorClosure blk;
a61af66fc99e Initial load duke parents: diff changeset	545 Universe::heap()->permanent_object_iterate(&blk);
a61af66fc99e Initial load duke parents: diff changeset	546 }
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548
a61af66fc99e Initial load duke parents: diff changeset	549 static bool has_run_finalizers_on_exit = false;
a61af66fc99e Initial load duke parents: diff changeset	550
a61af66fc99e Initial load duke parents: diff changeset	551 void Universe::run_finalizers_on_exit() {
a61af66fc99e Initial load duke parents: diff changeset	552 if (has_run_finalizers_on_exit) return;
a61af66fc99e Initial load duke parents: diff changeset	553 has_run_finalizers_on_exit = true;
a61af66fc99e Initial load duke parents: diff changeset	554
a61af66fc99e Initial load duke parents: diff changeset	555 // Called on VM exit. This ought to be run in a separate thread.
a61af66fc99e Initial load duke parents: diff changeset	556 if (TraceReferenceGC) tty->print_cr("Callback to run finalizers on exit");
a61af66fc99e Initial load duke parents: diff changeset	557 {
a61af66fc99e Initial load duke parents: diff changeset	558 PRESERVE_EXCEPTION_MARK;
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	559 KlassHandle finalizer_klass(THREAD, SystemDictionary::Finalizer_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	560 JavaValue result(T_VOID);
a61af66fc99e Initial load duke parents: diff changeset	561 JavaCalls::call_static(
a61af66fc99e Initial load duke parents: diff changeset	562 &result,
a61af66fc99e Initial load duke parents: diff changeset	563 finalizer_klass,
a61af66fc99e Initial load duke parents: diff changeset	564 vmSymbolHandles::run_finalizers_on_exit_name(),
a61af66fc99e Initial load duke parents: diff changeset	565 vmSymbolHandles::void_method_signature(),
a61af66fc99e Initial load duke parents: diff changeset	566 THREAD
a61af66fc99e Initial load duke parents: diff changeset	567 );
a61af66fc99e Initial load duke parents: diff changeset	568 // Ignore any pending exceptions
a61af66fc99e Initial load duke parents: diff changeset	569 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	570 }
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573
a61af66fc99e Initial load duke parents: diff changeset	574 // initialize_vtable could cause gc if
a61af66fc99e Initial load duke parents: diff changeset	575 // 1) we specified true to initialize_vtable and
a61af66fc99e Initial load duke parents: diff changeset	576 // 2) this ran after gc was enabled
a61af66fc99e Initial load duke parents: diff changeset	577 // In case those ever change we use handles for oops
a61af66fc99e Initial load duke parents: diff changeset	578 void Universe::reinitialize_vtable_of(KlassHandle k_h, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	579 // init vtable of k and all subclasses
a61af66fc99e Initial load duke parents: diff changeset	580 Klass* ko = k_h()->klass_part();
a61af66fc99e Initial load duke parents: diff changeset	581 klassVtable* vt = ko->vtable();
a61af66fc99e Initial load duke parents: diff changeset	582 if (vt) vt->initialize_vtable(false, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	583 if (ko->oop_is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	584 instanceKlass* ik = (instanceKlass*)ko;
a61af66fc99e Initial load duke parents: diff changeset	585 for (KlassHandle s_h(THREAD, ik->subklass()); s_h() != NULL; s_h = (THREAD, s_h()->klass_part()->next_sibling())) {
a61af66fc99e Initial load duke parents: diff changeset	586 reinitialize_vtable_of(s_h, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	587 }
a61af66fc99e Initial load duke parents: diff changeset	588 }
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 void initialize_itable_for_klass(klassOop k, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	593 instanceKlass::cast(k)->itable()->initialize_itable(false, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	594 }
a61af66fc99e Initial load duke parents: diff changeset	595
a61af66fc99e Initial load duke parents: diff changeset	596
a61af66fc99e Initial load duke parents: diff changeset	597 void Universe::reinitialize_itables(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	598 SystemDictionary::classes_do(initialize_itable_for_klass, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	599
a61af66fc99e Initial load duke parents: diff changeset	600 }
a61af66fc99e Initial load duke parents: diff changeset	601
a61af66fc99e Initial load duke parents: diff changeset	602
a61af66fc99e Initial load duke parents: diff changeset	603 bool Universe::on_page_boundary(void* addr) {
a61af66fc99e Initial load duke parents: diff changeset	604 return ((uintptr_t) addr) % os::vm_page_size() == 0;
a61af66fc99e Initial load duke parents: diff changeset	605 }
a61af66fc99e Initial load duke parents: diff changeset	606
a61af66fc99e Initial load duke parents: diff changeset	607
a61af66fc99e Initial load duke parents: diff changeset	608 bool Universe::should_fill_in_stack_trace(Handle throwable) {
a61af66fc99e Initial load duke parents: diff changeset	609 // never attempt to fill in the stack trace of preallocated errors that do not have
a61af66fc99e Initial load duke parents: diff changeset	610 // backtrace. These errors are kept alive forever and may be "re-used" when all
a61af66fc99e Initial load duke parents: diff changeset	611 // preallocated errors with backtrace have been consumed. Also need to avoid
a61af66fc99e Initial load duke parents: diff changeset	612 // a potential loop which could happen if an out of memory occurs when attempting
a61af66fc99e Initial load duke parents: diff changeset	613 // to allocate the backtrace.
a61af66fc99e Initial load duke parents: diff changeset	614 return ((throwable() != Universe::_out_of_memory_error_java_heap) &&
a61af66fc99e Initial load duke parents: diff changeset	615 (throwable() != Universe::_out_of_memory_error_perm_gen) &&
a61af66fc99e Initial load duke parents: diff changeset	616 (throwable() != Universe::_out_of_memory_error_array_size) &&
a61af66fc99e Initial load duke parents: diff changeset	617 (throwable() != Universe::_out_of_memory_error_gc_overhead_limit));
a61af66fc99e Initial load duke parents: diff changeset	618 }
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620
a61af66fc99e Initial load duke parents: diff changeset	621 oop Universe::gen_out_of_memory_error(oop default_err) {
a61af66fc99e Initial load duke parents: diff changeset	622 // generate an out of memory error:
a61af66fc99e Initial load duke parents: diff changeset	623 // - if there is a preallocated error with backtrace available then return it wth
a61af66fc99e Initial load duke parents: diff changeset	624 // a filled in stack trace.
a61af66fc99e Initial load duke parents: diff changeset	625 // - if there are no preallocated errors with backtrace available then return
a61af66fc99e Initial load duke parents: diff changeset	626 // an error without backtrace.
a61af66fc99e Initial load duke parents: diff changeset	627 int next;
a61af66fc99e Initial load duke parents: diff changeset	628 if (_preallocated_out_of_memory_error_avail_count > 0) {
a61af66fc99e Initial load duke parents: diff changeset	629 next = (int)Atomic::add(-1, &_preallocated_out_of_memory_error_avail_count);
a61af66fc99e Initial load duke parents: diff changeset	630 assert(next < (int)PreallocatedOutOfMemoryErrorCount, "avail count is corrupt");
a61af66fc99e Initial load duke parents: diff changeset	631 } else {
a61af66fc99e Initial load duke parents: diff changeset	632 next = -1;
a61af66fc99e Initial load duke parents: diff changeset	633 }
a61af66fc99e Initial load duke parents: diff changeset	634 if (next < 0) {
a61af66fc99e Initial load duke parents: diff changeset	635 // all preallocated errors have been used.
a61af66fc99e Initial load duke parents: diff changeset	636 // return default
a61af66fc99e Initial load duke parents: diff changeset	637 return default_err;
a61af66fc99e Initial load duke parents: diff changeset	638 } else {
a61af66fc99e Initial load duke parents: diff changeset	639 // get the error object at the slot and set set it to NULL so that the
a61af66fc99e Initial load duke parents: diff changeset	640 // array isn't keeping it alive anymore.
a61af66fc99e Initial load duke parents: diff changeset	641 oop exc = preallocated_out_of_memory_errors()->obj_at(next);
a61af66fc99e Initial load duke parents: diff changeset	642 assert(exc != NULL, "slot has been used already");
a61af66fc99e Initial load duke parents: diff changeset	643 preallocated_out_of_memory_errors()->obj_at_put(next, NULL);
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 // use the message from the default error
a61af66fc99e Initial load duke parents: diff changeset	646 oop msg = java_lang_Throwable::message(default_err);
a61af66fc99e Initial load duke parents: diff changeset	647 assert(msg != NULL, "no message");
a61af66fc99e Initial load duke parents: diff changeset	648 java_lang_Throwable::set_message(exc, msg);
a61af66fc99e Initial load duke parents: diff changeset	649
a61af66fc99e Initial load duke parents: diff changeset	650 // populate the stack trace and return it.
a61af66fc99e Initial load duke parents: diff changeset	651 java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(exc);
a61af66fc99e Initial load duke parents: diff changeset	652 return exc;
a61af66fc99e Initial load duke parents: diff changeset	653 }
a61af66fc99e Initial load duke parents: diff changeset	654 }
a61af66fc99e Initial load duke parents: diff changeset	655
a61af66fc99e Initial load duke parents: diff changeset	656 static intptr_t non_oop_bits = 0;
a61af66fc99e Initial load duke parents: diff changeset	657
a61af66fc99e Initial load duke parents: diff changeset	658 void* Universe::non_oop_word() {
a61af66fc99e Initial load duke parents: diff changeset	659 // Neither the high bits nor the low bits of this value is allowed
a61af66fc99e Initial load duke parents: diff changeset	660 // to look like (respectively) the high or low bits of a real oop.
a61af66fc99e Initial load duke parents: diff changeset	661 //
a61af66fc99e Initial load duke parents: diff changeset	662 // High and low are CPU-specific notions, but low always includes
a61af66fc99e Initial load duke parents: diff changeset	663 // the low-order bit. Since oops are always aligned at least mod 4,
a61af66fc99e Initial load duke parents: diff changeset	664 // setting the low-order bit will ensure that the low half of the
a61af66fc99e Initial load duke parents: diff changeset	665 // word will never look like that of a real oop.
a61af66fc99e Initial load duke parents: diff changeset	666 //
a61af66fc99e Initial load duke parents: diff changeset	667 // Using the OS-supplied non-memory-address word (usually 0 or -1)
a61af66fc99e Initial load duke parents: diff changeset	668 // will take care of the high bits, however many there are.
a61af66fc99e Initial load duke parents: diff changeset	669
a61af66fc99e Initial load duke parents: diff changeset	670 if (non_oop_bits == 0) {
a61af66fc99e Initial load duke parents: diff changeset	671 non_oop_bits = (intptr_t)os::non_memory_address_word() \| 1;
a61af66fc99e Initial load duke parents: diff changeset	672 }
a61af66fc99e Initial load duke parents: diff changeset	673
a61af66fc99e Initial load duke parents: diff changeset	674 return (void*)non_oop_bits;
a61af66fc99e Initial load duke parents: diff changeset	675 }
a61af66fc99e Initial load duke parents: diff changeset	676
a61af66fc99e Initial load duke parents: diff changeset	677 jint universe_init() {
a61af66fc99e Initial load duke parents: diff changeset	678 assert(!Universe::_fully_initialized, "called after initialize_vtables");
a61af66fc99e Initial load duke parents: diff changeset	679 guarantee(1 << LogHeapWordSize == sizeof(HeapWord),
a61af66fc99e Initial load duke parents: diff changeset	680 "LogHeapWordSize is incorrect.");
a61af66fc99e Initial load duke parents: diff changeset	681 guarantee(sizeof(oop) >= sizeof(HeapWord), "HeapWord larger than oop?");
a61af66fc99e Initial load duke parents: diff changeset	682 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	683 "oop size is not not a multiple of HeapWord size");
0 a61af66fc99e Initial load duke parents: diff changeset	684 TraceTime timer("Genesis", TraceStartupTime);
a61af66fc99e Initial load duke parents: diff changeset	685 GC_locker::lock(); // do not allow gc during bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	686 JavaClasses::compute_hard_coded_offsets();
a61af66fc99e Initial load duke parents: diff changeset	687
a61af66fc99e Initial load duke parents: diff changeset	688 // Get map info from shared archive file.
a61af66fc99e Initial load duke parents: diff changeset	689 if (DumpSharedSpaces)
a61af66fc99e Initial load duke parents: diff changeset	690 UseSharedSpaces = false;
a61af66fc99e Initial load duke parents: diff changeset	691
a61af66fc99e Initial load duke parents: diff changeset	692 FileMapInfo* mapinfo = NULL;
a61af66fc99e Initial load duke parents: diff changeset	693 if (UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	694 mapinfo = NEW_C_HEAP_OBJ(FileMapInfo);
a61af66fc99e Initial load duke parents: diff changeset	695 memset(mapinfo, 0, sizeof(FileMapInfo));
a61af66fc99e Initial load duke parents: diff changeset	696
a61af66fc99e Initial load duke parents: diff changeset	697 // Open the shared archive file, read and validate the header. If
a61af66fc99e Initial load duke parents: diff changeset	698 // initialization files, shared spaces [UseSharedSpaces] are
a61af66fc99e Initial load duke parents: diff changeset	699 // disabled and the file is closed.
a61af66fc99e Initial load duke parents: diff changeset	700
a61af66fc99e Initial load duke parents: diff changeset	701 if (mapinfo->initialize()) {
a61af66fc99e Initial load duke parents: diff changeset	702 FileMapInfo::set_current_info(mapinfo);
a61af66fc99e Initial load duke parents: diff changeset	703 } else {
a61af66fc99e Initial load duke parents: diff changeset	704 assert(!mapinfo->is_open() && !UseSharedSpaces,
a61af66fc99e Initial load duke parents: diff changeset	705 "archive file not closed or shared spaces not disabled.");
a61af66fc99e Initial load duke parents: diff changeset	706 }
a61af66fc99e Initial load duke parents: diff changeset	707 }
a61af66fc99e Initial load duke parents: diff changeset	708
a61af66fc99e Initial load duke parents: diff changeset	709 jint status = Universe::initialize_heap();
a61af66fc99e Initial load duke parents: diff changeset	710 if (status != JNI_OK) {
a61af66fc99e Initial load duke parents: diff changeset	711 return status;
a61af66fc99e Initial load duke parents: diff changeset	712 }
a61af66fc99e Initial load duke parents: diff changeset	713
a61af66fc99e Initial load duke parents: diff changeset	714 // We have a heap so create the methodOop caches before
a61af66fc99e Initial load duke parents: diff changeset	715 // CompactingPermGenGen::initialize_oops() tries to populate them.
a61af66fc99e Initial load duke parents: diff changeset	716 Universe::_finalizer_register_cache = new LatestMethodOopCache();
a61af66fc99e Initial load duke parents: diff changeset	717 Universe::_loader_addClass_cache = new LatestMethodOopCache();
a61af66fc99e Initial load duke parents: diff changeset	718 Universe::_reflect_invoke_cache = new ActiveMethodOopsCache();
a61af66fc99e Initial load duke parents: diff changeset	719
a61af66fc99e Initial load duke parents: diff changeset	720 if (UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	721
a61af66fc99e Initial load duke parents: diff changeset	722 // Read the data structures supporting the shared spaces (shared
a61af66fc99e Initial load duke parents: diff changeset	723 // system dictionary, symbol table, etc.). After that, access to
a61af66fc99e Initial load duke parents: diff changeset	724 // the file (other than the mapped regions) is no longer needed, and
a61af66fc99e Initial load duke parents: diff changeset	725 // the file is closed. Closing the file does not affect the
a61af66fc99e Initial load duke parents: diff changeset	726 // currently mapped regions.
a61af66fc99e Initial load duke parents: diff changeset	727
a61af66fc99e Initial load duke parents: diff changeset	728 CompactingPermGenGen::initialize_oops();
a61af66fc99e Initial load duke parents: diff changeset	729 mapinfo->close();
a61af66fc99e Initial load duke parents: diff changeset	730
a61af66fc99e Initial load duke parents: diff changeset	731 } else {
a61af66fc99e Initial load duke parents: diff changeset	732 SymbolTable::create_table();
a61af66fc99e Initial load duke parents: diff changeset	733 StringTable::create_table();
a61af66fc99e Initial load duke parents: diff changeset	734 ClassLoader::create_package_info_table();
a61af66fc99e Initial load duke parents: diff changeset	735 }
a61af66fc99e Initial load duke parents: diff changeset	736
a61af66fc99e Initial load duke parents: diff changeset	737 return JNI_OK;
a61af66fc99e Initial load duke parents: diff changeset	738 }
a61af66fc99e Initial load duke parents: diff changeset	739
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	740 // 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	741 // when compressed oops are used:
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	742 // 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	743 // NarrowOopHeapBaseMin + heap_size < 4Gb
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	744 // 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	745 // NarrowOopHeapBaseMin + heap_size < 32Gb
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	746 // 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	747
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	748 // 4Gb
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	749 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	750 // 32Gb
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1507 diff changeset	751 // OopEncodingHeapMax == NarrowOopHeapMax << LogMinObjAlignmentInBytes;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	752
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	753 char* Universe::preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode) {
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	754 size_t base = 0;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	755 #ifdef _LP64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	756 if (UseCompressedOops) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	757 assert(mode == UnscaledNarrowOop \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	758 mode == ZeroBasedNarrowOop \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	759 mode == HeapBasedNarrowOop, "mode is invalid");
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	760 const size_t total_size = heap_size + HeapBaseMinAddress;
922 1a81ea4b45d4 6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop") kvn parents: 845 diff changeset	761 // Return specified base for the first request.
1a81ea4b45d4 6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop") kvn parents: 845 diff changeset	762 if (!FLAG_IS_DEFAULT(HeapBaseMinAddress) && (mode == UnscaledNarrowOop)) {
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	763 base = HeapBaseMinAddress;
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	764 } else if (total_size <= OopEncodingHeapMax && (mode != HeapBasedNarrowOop)) {
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	765 if (total_size <= NarrowOopHeapMax && (mode == UnscaledNarrowOop) &&
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	766 (Universe::narrow_oop_shift() == 0)) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	767 // Use 32-bits oops without encoding and
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	768 // 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	769 base = (NarrowOopHeapMax - heap_size);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	770 } else {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	771 // Can't reserve with NarrowOopShift == 0
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	772 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	773 if (mode == UnscaledNarrowOop \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	774 mode == ZeroBasedNarrowOop && total_size <= NarrowOopHeapMax) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	775 // 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	776 // 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	777 // 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	778 base = (OopEncodingHeapMax - heap_size);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	779 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	780 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	781 } else {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	782 // Can't reserve below 32Gb.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	783 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	784 }
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	785 // 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	786 // 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	787 // The final values 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	788 if (base != 0 && (base + heap_size) <= OopEncodingHeapMax) {
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	789 // 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	790 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	791 // 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	792 // 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	793 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	794 } else {
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	795 // 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	796 // 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	797 // 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	798 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	799 #ifdef _WIN64
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	800 if (UseLargePages) {
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	801 // 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	802 // 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	803 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	804 }
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	805 #endif // _WIN64
f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	806 }
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	807 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	808 #endif
1057 f334aec453a1 6896084: VM does not reserve protected page below heap for compressed oops implicit null checks kvn parents: 922 diff changeset	809 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	810 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	811
0 a61af66fc99e Initial load duke parents: diff changeset	812 jint Universe::initialize_heap() {
a61af66fc99e Initial load duke parents: diff changeset	813
a61af66fc99e Initial load duke parents: diff changeset	814 if (UseParallelGC) {
a61af66fc99e Initial load duke parents: diff changeset	815 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	816 Universe::_collectedHeap = new ParallelScavengeHeap();
a61af66fc99e Initial load duke parents: diff changeset	817 #else // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	818 fatal("UseParallelGC not supported in java kernel vm.");
a61af66fc99e Initial load duke parents: diff changeset	819 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	820
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	821 } else if (UseG1GC) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	822 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	823 G1CollectorPolicy* g1p = new G1CollectorPolicy_BestRegionsFirst();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	824 G1CollectedHeap* g1h = new G1CollectedHeap(g1p);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	825 Universe::_collectedHeap = g1h;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	826 #else // SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	827 fatal("UseG1GC not supported in java kernel vm.");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	828 #endif // SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	829
0 a61af66fc99e Initial load duke parents: diff changeset	830 } else {
a61af66fc99e Initial load duke parents: diff changeset	831 GenCollectorPolicy *gc_policy;
a61af66fc99e Initial load duke parents: diff changeset	832
a61af66fc99e Initial load duke parents: diff changeset	833 if (UseSerialGC) {
a61af66fc99e Initial load duke parents: diff changeset	834 gc_policy = new MarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	835 } else if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	836 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	837 if (UseAdaptiveSizePolicy) {
a61af66fc99e Initial load duke parents: diff changeset	838 gc_policy = new ASConcurrentMarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	839 } else {
a61af66fc99e Initial load duke parents: diff changeset	840 gc_policy = new ConcurrentMarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	841 }
a61af66fc99e Initial load duke parents: diff changeset	842 #else // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	843 fatal("UseConcMarkSweepGC not supported in java kernel vm.");
a61af66fc99e Initial load duke parents: diff changeset	844 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	845 } else { // default old generation
a61af66fc99e Initial load duke parents: diff changeset	846 gc_policy = new MarkSweepPolicy();
a61af66fc99e Initial load duke parents: diff changeset	847 }
a61af66fc99e Initial load duke parents: diff changeset	848
a61af66fc99e Initial load duke parents: diff changeset	849 Universe::_collectedHeap = new GenCollectedHeap(gc_policy);
a61af66fc99e Initial load duke parents: diff changeset	850 }
a61af66fc99e Initial load duke parents: diff changeset	851
a61af66fc99e Initial load duke parents: diff changeset	852 jint status = Universe::heap()->initialize();
a61af66fc99e Initial load duke parents: diff changeset	853 if (status != JNI_OK) {
a61af66fc99e Initial load duke parents: diff changeset	854 return status;
a61af66fc99e Initial load duke parents: diff changeset	855 }
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	856
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	857 #ifdef _LP64
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	858 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	859 // 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	860 // 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	861 // 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	862 // See needs_explicit_null_check.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	863 // 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	864 // compressed oops for pstack code.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	865 if (PrintCompressedOopsMode) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	866 tty->cr();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	867 tty->print("heap address: "PTR_FORMAT, Universe::heap()->base());
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	868 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	869 if ((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	870 // Can't reserve heap below 32Gb.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	871 Universe::set_narrow_oop_base(Universe::heap()->base() - os::vm_page_size());
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	872 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	873 if (PrintCompressedOopsMode) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	874 tty->print(", Compressed Oops with base: "PTR_FORMAT, Universe::narrow_oop_base());
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	875 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	876 } else {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	877 Universe::set_narrow_oop_base(0);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	878 if (PrintCompressedOopsMode) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	879 tty->print(", zero based Compressed Oops");
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	880 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	881 #ifdef _WIN64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	882 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	883 // 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	884 // mode with zero based Compressed Oops.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	885 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	886 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	887 #endif // _WIN64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	888 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	889 // Can't reserve heap below 4Gb.
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	890 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	891 } else {
922 1a81ea4b45d4 6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop") kvn parents: 845 diff changeset	892 Universe::set_narrow_oop_shift(0);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	893 if (PrintCompressedOopsMode) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	894 tty->print(", 32-bits Oops");
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	895 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	896 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	897 }
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	898 if (PrintCompressedOopsMode) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	899 tty->cr();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	900 tty->cr();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	901 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	902 }
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	903 assert(Universe::narrow_oop_base() == (Universe::heap()->base() - os::vm_page_size()) \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	904 Universe::narrow_oop_base() == NULL, "invalid value");
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	905 assert(Universe::narrow_oop_shift() == LogMinObjAlignmentInBytes \|\|
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	906 Universe::narrow_oop_shift() == 0, "invalid value");
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	907 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	908
a61af66fc99e Initial load duke parents: diff changeset	909 // We will never reach the CATCH below since Exceptions::_throw will cause
a61af66fc99e Initial load duke parents: diff changeset	910 // the VM to exit if an exception is thrown during initialization
a61af66fc99e Initial load duke parents: diff changeset	911
a61af66fc99e Initial load duke parents: diff changeset	912 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	913 assert(Universe::heap()->supports_tlab_allocation(),
a61af66fc99e Initial load duke parents: diff changeset	914 "Should support thread-local allocation buffers");
a61af66fc99e Initial load duke parents: diff changeset	915 ThreadLocalAllocBuffer::startup_initialization();
a61af66fc99e Initial load duke parents: diff changeset	916 }
a61af66fc99e Initial load duke parents: diff changeset	917 return JNI_OK;
a61af66fc99e Initial load duke parents: diff changeset	918 }
a61af66fc99e Initial load duke parents: diff changeset	919
a61af66fc99e Initial load duke parents: diff changeset	920 // It's the caller's repsonsibility to ensure glitch-freedom
a61af66fc99e Initial load duke parents: diff changeset	921 // (if required).
a61af66fc99e Initial load duke parents: diff changeset	922 void Universe::update_heap_info_at_gc() {
a61af66fc99e Initial load duke parents: diff changeset	923 _heap_capacity_at_last_gc = heap()->capacity();
a61af66fc99e Initial load duke parents: diff changeset	924 _heap_used_at_last_gc = heap()->used();
a61af66fc99e Initial load duke parents: diff changeset	925 }
a61af66fc99e Initial load duke parents: diff changeset	926
a61af66fc99e Initial load duke parents: diff changeset	927
a61af66fc99e Initial load duke parents: diff changeset	928
a61af66fc99e Initial load duke parents: diff changeset	929 void universe2_init() {
a61af66fc99e Initial load duke parents: diff changeset	930 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	931 Universe::genesis(CATCH);
a61af66fc99e Initial load duke parents: diff changeset	932 // Although we'd like to verify here that the state of the heap
a61af66fc99e Initial load duke parents: diff changeset	933 // is good, we can't because the main thread has not yet added
a61af66fc99e Initial load duke parents: diff changeset	934 // itself to the threads list (so, using current interfaces
a61af66fc99e Initial load duke parents: diff changeset	935 // we can't "fill" its TLAB), unless TLABs are disabled.
a61af66fc99e Initial load duke parents: diff changeset	936 if (VerifyBeforeGC && !UseTLAB &&
a61af66fc99e Initial load duke parents: diff changeset	937 Universe::heap()->total_collections() >= VerifyGCStartAt) {
a61af66fc99e Initial load duke parents: diff changeset	938 Universe::heap()->prepare_for_verify();
a61af66fc99e Initial load duke parents: diff changeset	939 Universe::verify(); // make sure we're starting with a clean slate
a61af66fc99e Initial load duke parents: diff changeset	940 }
a61af66fc99e Initial load duke parents: diff changeset	941 }
a61af66fc99e Initial load duke parents: diff changeset	942
a61af66fc99e Initial load duke parents: diff changeset	943
a61af66fc99e Initial load duke parents: diff changeset	944 // This function is defined in JVM.cpp
a61af66fc99e Initial load duke parents: diff changeset	945 extern void initialize_converter_functions();
a61af66fc99e Initial load duke parents: diff changeset	946
a61af66fc99e Initial load duke parents: diff changeset	947 bool universe_post_init() {
a61af66fc99e Initial load duke parents: diff changeset	948 Universe::_fully_initialized = true;
a61af66fc99e Initial load duke parents: diff changeset	949 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	950 { ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	951 Interpreter::initialize(); // needed for interpreter entry points
a61af66fc99e Initial load duke parents: diff changeset	952 if (!UseSharedSpaces) {
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	953 KlassHandle ok_h(THREAD, SystemDictionary::Object_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	954 Universe::reinitialize_vtable_of(ok_h, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	955 Universe::reinitialize_itables(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	956 }
a61af66fc99e Initial load duke parents: diff changeset	957 }
a61af66fc99e Initial load duke parents: diff changeset	958
a61af66fc99e Initial load duke parents: diff changeset	959 klassOop k;
a61af66fc99e Initial load duke parents: diff changeset	960 instanceKlassHandle k_h;
a61af66fc99e Initial load duke parents: diff changeset	961 if (!UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	962 // Setup preallocated empty java.lang.Class array
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	963 Universe::_the_empty_class_klass_array = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	964 // Setup preallocated OutOfMemoryError errors
a61af66fc99e Initial load duke parents: diff changeset	965 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_OutOfMemoryError(), true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	966 k_h = instanceKlassHandle(THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	967 Universe::_out_of_memory_error_java_heap = k_h->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	968 Universe::_out_of_memory_error_perm_gen = k_h->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	969 Universe::_out_of_memory_error_array_size = k_h->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	970 Universe::_out_of_memory_error_gc_overhead_limit =
a61af66fc99e Initial load duke parents: diff changeset	971 k_h->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	972
a61af66fc99e Initial load duke parents: diff changeset	973 // Setup preallocated NullPointerException
a61af66fc99e Initial load duke parents: diff changeset	974 // (this is currently used for a cheap & dirty solution in compiler exception handling)
a61af66fc99e Initial load duke parents: diff changeset	975 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_NullPointerException(), true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	976 Universe::_null_ptr_exception_instance = instanceKlass::cast(k)->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	977 // Setup preallocated ArithmeticException
a61af66fc99e Initial load duke parents: diff changeset	978 // (this is currently used for a cheap & dirty solution in compiler exception handling)
a61af66fc99e Initial load duke parents: diff changeset	979 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ArithmeticException(), true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	980 Universe::_arithmetic_exception_instance = instanceKlass::cast(k)->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	981 // Virtual Machine Error for when we get into a situation we can't resolve
a61af66fc99e Initial load duke parents: diff changeset	982 k = SystemDictionary::resolve_or_fail(
a61af66fc99e Initial load duke parents: diff changeset	983 vmSymbolHandles::java_lang_VirtualMachineError(), true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	984 bool linked = instanceKlass::cast(k)->link_class_or_fail(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	985 if (!linked) {
a61af66fc99e Initial load duke parents: diff changeset	986 tty->print_cr("Unable to link/verify VirtualMachineError class");
a61af66fc99e Initial load duke parents: diff changeset	987 return false; // initialization failed
a61af66fc99e Initial load duke parents: diff changeset	988 }
a61af66fc99e Initial load duke parents: diff changeset	989 Universe::_virtual_machine_error_instance =
a61af66fc99e Initial load duke parents: diff changeset	990 instanceKlass::cast(k)->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	991 }
a61af66fc99e Initial load duke parents: diff changeset	992 if (!DumpSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	993 // These are the only Java fields that are currently set during shared space dumping.
a61af66fc99e Initial load duke parents: diff changeset	994 // We prefer to not handle this generally, so we always reinitialize these detail messages.
a61af66fc99e Initial load duke parents: diff changeset	995 Handle msg = java_lang_String::create_from_str("Java heap space", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	996 java_lang_Throwable::set_message(Universe::_out_of_memory_error_java_heap, msg());
a61af66fc99e Initial load duke parents: diff changeset	997
a61af66fc99e Initial load duke parents: diff changeset	998 msg = java_lang_String::create_from_str("PermGen space", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	999 java_lang_Throwable::set_message(Universe::_out_of_memory_error_perm_gen, msg());
a61af66fc99e Initial load duke parents: diff changeset	1000
a61af66fc99e Initial load duke parents: diff changeset	1001 msg = java_lang_String::create_from_str("Requested array size exceeds VM limit", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1002 java_lang_Throwable::set_message(Universe::_out_of_memory_error_array_size, msg());
a61af66fc99e Initial load duke parents: diff changeset	1003
a61af66fc99e Initial load duke parents: diff changeset	1004 msg = java_lang_String::create_from_str("GC overhead limit exceeded", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1005 java_lang_Throwable::set_message(Universe::_out_of_memory_error_gc_overhead_limit, msg());
a61af66fc99e Initial load duke parents: diff changeset	1006
a61af66fc99e Initial load duke parents: diff changeset	1007 msg = java_lang_String::create_from_str("/ by zero", CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1008 java_lang_Throwable::set_message(Universe::_arithmetic_exception_instance, msg());
a61af66fc99e Initial load duke parents: diff changeset	1009
a61af66fc99e Initial load duke parents: diff changeset	1010 // Setup the array of errors that have preallocated backtrace
a61af66fc99e Initial load duke parents: diff changeset	1011 k = Universe::_out_of_memory_error_java_heap->klass();
a61af66fc99e Initial load duke parents: diff changeset	1012 assert(k->klass_part()->name() == vmSymbols::java_lang_OutOfMemoryError(), "should be out of memory error");
a61af66fc99e Initial load duke parents: diff changeset	1013 k_h = instanceKlassHandle(THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	1014
a61af66fc99e Initial load duke parents: diff changeset	1015 int len = (StackTraceInThrowable) ? (int)PreallocatedOutOfMemoryErrorCount : 0;
a61af66fc99e Initial load duke parents: diff changeset	1016 Universe::_preallocated_out_of_memory_error_array = oopFactory::new_objArray(k_h(), len, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1017 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1018 oop err = k_h->allocate_permanent_instance(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1019 Handle err_h = Handle(THREAD, err);
a61af66fc99e Initial load duke parents: diff changeset	1020 java_lang_Throwable::allocate_backtrace(err_h, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1021 Universe::preallocated_out_of_memory_errors()->obj_at_put(i, err_h());
a61af66fc99e Initial load duke parents: diff changeset	1022 }
a61af66fc99e Initial load duke parents: diff changeset	1023 Universe::_preallocated_out_of_memory_error_avail_count = (jint)len;
a61af66fc99e Initial load duke parents: diff changeset	1024 }
a61af66fc99e Initial load duke parents: diff changeset	1025
a61af66fc99e Initial load duke parents: diff changeset	1026
a61af66fc99e Initial load duke parents: diff changeset	1027 // Setup static method for registering finalizers
a61af66fc99e Initial load duke parents: diff changeset	1028 // The finalizer klass must be linked before looking up the method, in
a61af66fc99e Initial load duke parents: diff changeset	1029 // case it needs to get rewritten.
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	1030 instanceKlass::cast(SystemDictionary::Finalizer_klass())->link_class(CHECK_false);
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	1031 methodOop m = instanceKlass::cast(SystemDictionary::Finalizer_klass())->find_method(
0 a61af66fc99e Initial load duke parents: diff changeset	1032 vmSymbols::register_method_name(),
a61af66fc99e Initial load duke parents: diff changeset	1033 vmSymbols::register_method_signature());
a61af66fc99e Initial load duke parents: diff changeset	1034 if (m == NULL \|\| !m->is_static()) {
a61af66fc99e Initial load duke parents: diff changeset	1035 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(),
a61af66fc99e Initial load duke parents: diff changeset	1036 "java.lang.ref.Finalizer.register", false);
a61af66fc99e Initial load duke parents: diff changeset	1037 }
a61af66fc99e Initial load duke parents: diff changeset	1038 Universe::_finalizer_register_cache->init(
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	1039 SystemDictionary::Finalizer_klass(), m, CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1040
a61af66fc99e Initial load duke parents: diff changeset	1041 // Resolve on first use and initialize class.
a61af66fc99e Initial load duke parents: diff changeset	1042 // Note: No race-condition here, since a resolve will always return the same result
a61af66fc99e Initial load duke parents: diff changeset	1043
a61af66fc99e Initial load duke parents: diff changeset	1044 // Setup method for security checks
a61af66fc99e Initial load duke parents: diff changeset	1045 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_reflect_Method(), true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1046 k_h = instanceKlassHandle(THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	1047 k_h->link_class(CHECK_false);
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1142 diff changeset	1048 m = k_h->find_method(vmSymbols::invoke_name(), vmSymbols::object_object_array_object_signature());
0 a61af66fc99e Initial load duke parents: diff changeset	1049 if (m == NULL \|\| m->is_static()) {
a61af66fc99e Initial load duke parents: diff changeset	1050 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(),
a61af66fc99e Initial load duke parents: diff changeset	1051 "java.lang.reflect.Method.invoke", false);
a61af66fc99e Initial load duke parents: diff changeset	1052 }
a61af66fc99e Initial load duke parents: diff changeset	1053 Universe::_reflect_invoke_cache->init(k_h(), m, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1054
a61af66fc99e Initial load duke parents: diff changeset	1055 // Setup method for registering loaded classes in class loader vector
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	1056 instanceKlass::cast(SystemDictionary::ClassLoader_klass())->link_class(CHECK_false);
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	1057 m = instanceKlass::cast(SystemDictionary::ClassLoader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature());
0 a61af66fc99e Initial load duke parents: diff changeset	1058 if (m == NULL \|\| m->is_static()) {
a61af66fc99e Initial load duke parents: diff changeset	1059 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(),
a61af66fc99e Initial load duke parents: diff changeset	1060 "java.lang.ClassLoader.addClass", false);
a61af66fc99e Initial load duke parents: diff changeset	1061 }
a61af66fc99e Initial load duke parents: diff changeset	1062 Universe::_loader_addClass_cache->init(
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1080 diff changeset	1063 SystemDictionary::ClassLoader_klass(), m, CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	1064
a61af66fc99e Initial load duke parents: diff changeset	1065 // The folowing is initializing converter functions for serialization in
a61af66fc99e Initial load duke parents: diff changeset	1066 // JVM.cpp. If we clean up the StrictMath code above we may want to find
a61af66fc99e Initial load duke parents: diff changeset	1067 // a better solution for this as well.
a61af66fc99e Initial load duke parents: diff changeset	1068 initialize_converter_functions();
a61af66fc99e Initial load duke parents: diff changeset	1069
a61af66fc99e Initial load duke parents: diff changeset	1070 // This needs to be done before the first scavenge/gc, since
a61af66fc99e Initial load duke parents: diff changeset	1071 // it's an input to soft ref clearing policy.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1072 {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1073 MutexLocker x(Heap_lock);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1074 Universe::update_heap_info_at_gc();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1075 }
0 a61af66fc99e Initial load duke parents: diff changeset	1076
a61af66fc99e Initial load duke parents: diff changeset	1077 // ("weak") refs processing infrastructure initialization
a61af66fc99e Initial load duke parents: diff changeset	1078 Universe::heap()->post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	1079
a61af66fc99e Initial load duke parents: diff changeset	1080 GC_locker::unlock(); // allow gc after bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	1081
a61af66fc99e Initial load duke parents: diff changeset	1082 MemoryService::set_universe_heap(Universe::_collectedHeap);
a61af66fc99e Initial load duke parents: diff changeset	1083 return true;
a61af66fc99e Initial load duke parents: diff changeset	1084 }
a61af66fc99e Initial load duke parents: diff changeset	1085
a61af66fc99e Initial load duke parents: diff changeset	1086
a61af66fc99e Initial load duke parents: diff changeset	1087 void Universe::compute_base_vtable_size() {
a61af66fc99e Initial load duke parents: diff changeset	1088 _base_vtable_size = ClassLoader::compute_Object_vtable();
a61af66fc99e Initial load duke parents: diff changeset	1089 }
a61af66fc99e Initial load duke parents: diff changeset	1090
a61af66fc99e Initial load duke parents: diff changeset	1091
a61af66fc99e Initial load duke parents: diff changeset	1092 // %%% The Universe::flush_foo methods belong in CodeCache.
a61af66fc99e Initial load duke parents: diff changeset	1093
a61af66fc99e Initial load duke parents: diff changeset	1094 // Flushes compiled methods dependent on dependee.
a61af66fc99e Initial load duke parents: diff changeset	1095 void Universe::flush_dependents_on(instanceKlassHandle dependee) {
a61af66fc99e Initial load duke parents: diff changeset	1096 assert_lock_strong(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	1097
a61af66fc99e Initial load duke parents: diff changeset	1098 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	1099
a61af66fc99e Initial load duke parents: diff changeset	1100 // CodeCache can only be updated by a thread_in_VM and they will all be
a61af66fc99e Initial load duke parents: diff changeset	1101 // stopped dring the safepoint so CodeCache will be safe to update without
a61af66fc99e Initial load duke parents: diff changeset	1102 // holding the CodeCache_lock.
a61af66fc99e Initial load duke parents: diff changeset	1103
a61af66fc99e Initial load duke parents: diff changeset	1104 DepChange changes(dependee);
a61af66fc99e Initial load duke parents: diff changeset	1105
a61af66fc99e Initial load duke parents: diff changeset	1106 // Compute the dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	1107 if (CodeCache::mark_for_deoptimization(changes) > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1108 // At least one nmethod has been marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	1109 VM_Deoptimize op;
a61af66fc99e Initial load duke parents: diff changeset	1110 VMThread::execute(&op);
a61af66fc99e Initial load duke parents: diff changeset	1111 }
a61af66fc99e Initial load duke parents: diff changeset	1112 }
a61af66fc99e Initial load duke parents: diff changeset	1113
a61af66fc99e Initial load duke parents: diff changeset	1114 #ifdef HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	1115 // Flushes compiled methods dependent on dependee in the evolutionary sense
a61af66fc99e Initial load duke parents: diff changeset	1116 void Universe::flush_evol_dependents_on(instanceKlassHandle ev_k_h) {
a61af66fc99e Initial load duke parents: diff changeset	1117 // --- Compile_lock is not held. However we are at a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	1118 assert_locked_or_safepoint(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	1119 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	1120
a61af66fc99e Initial load duke parents: diff changeset	1121 // CodeCache can only be updated by a thread_in_VM and they will all be
a61af66fc99e Initial load duke parents: diff changeset	1122 // stopped dring the safepoint so CodeCache will be safe to update without
a61af66fc99e Initial load duke parents: diff changeset	1123 // holding the CodeCache_lock.
a61af66fc99e Initial load duke parents: diff changeset	1124
a61af66fc99e Initial load duke parents: diff changeset	1125 // Compute the dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	1126 if (CodeCache::mark_for_evol_deoptimization(ev_k_h) > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1127 // At least one nmethod has been marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	1128
a61af66fc99e Initial load duke parents: diff changeset	1129 // All this already happens inside a VM_Operation, so we'll do all the work here.
a61af66fc99e Initial load duke parents: diff changeset	1130 // Stuff copied from VM_Deoptimize and modified slightly.
a61af66fc99e Initial load duke parents: diff changeset	1131
a61af66fc99e Initial load duke parents: diff changeset	1132 // 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	1133 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1134 DeoptimizationMarker dm;
a61af66fc99e Initial load duke parents: diff changeset	1135
a61af66fc99e Initial load duke parents: diff changeset	1136 // Deoptimize all activations depending on marked nmethods
a61af66fc99e Initial load duke parents: diff changeset	1137 Deoptimization::deoptimize_dependents();
a61af66fc99e Initial load duke parents: diff changeset	1138
a61af66fc99e Initial load duke parents: diff changeset	1139 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies)
a61af66fc99e Initial load duke parents: diff changeset	1140 CodeCache::make_marked_nmethods_not_entrant();
a61af66fc99e Initial load duke parents: diff changeset	1141 }
a61af66fc99e Initial load duke parents: diff changeset	1142 }
a61af66fc99e Initial load duke parents: diff changeset	1143 #endif // HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	1144
a61af66fc99e Initial load duke parents: diff changeset	1145
a61af66fc99e Initial load duke parents: diff changeset	1146 // Flushes compiled methods dependent on dependee
a61af66fc99e Initial load duke parents: diff changeset	1147 void Universe::flush_dependents_on_method(methodHandle m_h) {
a61af66fc99e Initial load duke parents: diff changeset	1148 // --- Compile_lock is not held. However we are at a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	1149 assert_locked_or_safepoint(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	1150
a61af66fc99e Initial load duke parents: diff changeset	1151 // CodeCache can only be updated by a thread_in_VM and they will all be
a61af66fc99e Initial load duke parents: diff changeset	1152 // stopped dring the safepoint so CodeCache will be safe to update without
a61af66fc99e Initial load duke parents: diff changeset	1153 // holding the CodeCache_lock.
a61af66fc99e Initial load duke parents: diff changeset	1154
a61af66fc99e Initial load duke parents: diff changeset	1155 // Compute the dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	1156 if (CodeCache::mark_for_deoptimization(m_h()) > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1157 // At least one nmethod has been marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	1158
a61af66fc99e Initial load duke parents: diff changeset	1159 // All this already happens inside a VM_Operation, so we'll do all the work here.
a61af66fc99e Initial load duke parents: diff changeset	1160 // Stuff copied from VM_Deoptimize and modified slightly.
a61af66fc99e Initial load duke parents: diff changeset	1161
a61af66fc99e Initial load duke parents: diff changeset	1162 // 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	1163 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1164 DeoptimizationMarker dm;
a61af66fc99e Initial load duke parents: diff changeset	1165
a61af66fc99e Initial load duke parents: diff changeset	1166 // Deoptimize all activations depending on marked nmethods
a61af66fc99e Initial load duke parents: diff changeset	1167 Deoptimization::deoptimize_dependents();
a61af66fc99e Initial load duke parents: diff changeset	1168
a61af66fc99e Initial load duke parents: diff changeset	1169 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies)
a61af66fc99e Initial load duke parents: diff changeset	1170 CodeCache::make_marked_nmethods_not_entrant();
a61af66fc99e Initial load duke parents: diff changeset	1171 }
a61af66fc99e Initial load duke parents: diff changeset	1172 }
a61af66fc99e Initial load duke parents: diff changeset	1173
a61af66fc99e Initial load duke parents: diff changeset	1174 void Universe::print() { print_on(gclog_or_tty); }
a61af66fc99e Initial load duke parents: diff changeset	1175
a61af66fc99e Initial load duke parents: diff changeset	1176 void Universe::print_on(outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	1177 st->print_cr("Heap");
a61af66fc99e Initial load duke parents: diff changeset	1178 heap()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1179 }
a61af66fc99e Initial load duke parents: diff changeset	1180
a61af66fc99e Initial load duke parents: diff changeset	1181 void Universe::print_heap_at_SIGBREAK() {
a61af66fc99e Initial load duke parents: diff changeset	1182 if (PrintHeapAtSIGBREAK) {
a61af66fc99e Initial load duke parents: diff changeset	1183 MutexLocker hl(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	1184 print_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	1185 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1186 tty->flush();
a61af66fc99e Initial load duke parents: diff changeset	1187 }
a61af66fc99e Initial load duke parents: diff changeset	1188 }
a61af66fc99e Initial load duke parents: diff changeset	1189
a61af66fc99e Initial load duke parents: diff changeset	1190 void Universe::print_heap_before_gc(outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	1191 st->print_cr("{Heap before GC invocations=%u (full %u):",
a61af66fc99e Initial load duke parents: diff changeset	1192 heap()->total_collections(),
a61af66fc99e Initial load duke parents: diff changeset	1193 heap()->total_full_collections());
a61af66fc99e Initial load duke parents: diff changeset	1194 heap()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1195 }
a61af66fc99e Initial load duke parents: diff changeset	1196
a61af66fc99e Initial load duke parents: diff changeset	1197 void Universe::print_heap_after_gc(outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	1198 st->print_cr("Heap after GC invocations=%u (full %u):",
a61af66fc99e Initial load duke parents: diff changeset	1199 heap()->total_collections(),
a61af66fc99e Initial load duke parents: diff changeset	1200 heap()->total_full_collections());
a61af66fc99e Initial load duke parents: diff changeset	1201 heap()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1202 st->print_cr("}");
a61af66fc99e Initial load duke parents: diff changeset	1203 }
a61af66fc99e Initial load duke parents: diff changeset	1204
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 647 diff changeset	1205 void Universe::verify(bool allow_dirty, bool silent, bool option) {
0 a61af66fc99e Initial load duke parents: diff changeset	1206 if (SharedSkipVerify) {
a61af66fc99e Initial load duke parents: diff changeset	1207 return;
a61af66fc99e Initial load duke parents: diff changeset	1208 }
a61af66fc99e Initial load duke parents: diff changeset	1209
a61af66fc99e Initial load duke parents: diff changeset	1210 // The use of _verify_in_progress is a temporary work around for
a61af66fc99e Initial load duke parents: diff changeset	1211 // 6320749. Don't bother with a creating a class to set and clear
a61af66fc99e Initial load duke parents: diff changeset	1212 // it since it is only used in this method and the control flow is
a61af66fc99e Initial load duke parents: diff changeset	1213 // straight forward.
a61af66fc99e Initial load duke parents: diff changeset	1214 _verify_in_progress = true;
a61af66fc99e Initial load duke parents: diff changeset	1215
a61af66fc99e Initial load duke parents: diff changeset	1216 COMPILER2_PRESENT(
a61af66fc99e Initial load duke parents: diff changeset	1217 assert(!DerivedPointerTable::is_active(),
a61af66fc99e Initial load duke parents: diff changeset	1218 "DPT should not be active during verification "
a61af66fc99e Initial load duke parents: diff changeset	1219 "(of thread stacks below)");
a61af66fc99e Initial load duke parents: diff changeset	1220 )
a61af66fc99e Initial load duke parents: diff changeset	1221
a61af66fc99e Initial load duke parents: diff changeset	1222 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1223 HandleMark hm; // Handles created during verification can be zapped
a61af66fc99e Initial load duke parents: diff changeset	1224 _verify_count++;
a61af66fc99e Initial load duke parents: diff changeset	1225
a61af66fc99e Initial load duke parents: diff changeset	1226 if (!silent) gclog_or_tty->print("[Verifying ");
a61af66fc99e Initial load duke parents: diff changeset	1227 if (!silent) gclog_or_tty->print("threads ");
a61af66fc99e Initial load duke parents: diff changeset	1228 Threads::verify();
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 647 diff changeset	1229 heap()->verify(allow_dirty, silent, option);
0 a61af66fc99e Initial load duke parents: diff changeset	1230
a61af66fc99e Initial load duke parents: diff changeset	1231 if (!silent) gclog_or_tty->print("syms ");
a61af66fc99e Initial load duke parents: diff changeset	1232 SymbolTable::verify();
a61af66fc99e Initial load duke parents: diff changeset	1233 if (!silent) gclog_or_tty->print("strs ");
a61af66fc99e Initial load duke parents: diff changeset	1234 StringTable::verify();
a61af66fc99e Initial load duke parents: diff changeset	1235 {
a61af66fc99e Initial load duke parents: diff changeset	1236 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	1237 if (!silent) gclog_or_tty->print("zone ");
a61af66fc99e Initial load duke parents: diff changeset	1238 CodeCache::verify();
a61af66fc99e Initial load duke parents: diff changeset	1239 }
a61af66fc99e Initial load duke parents: diff changeset	1240 if (!silent) gclog_or_tty->print("dict ");
a61af66fc99e Initial load duke parents: diff changeset	1241 SystemDictionary::verify();
a61af66fc99e Initial load duke parents: diff changeset	1242 if (!silent) gclog_or_tty->print("hand ");
a61af66fc99e Initial load duke parents: diff changeset	1243 JNIHandles::verify();
a61af66fc99e Initial load duke parents: diff changeset	1244 if (!silent) gclog_or_tty->print("C-heap ");
a61af66fc99e Initial load duke parents: diff changeset	1245 os::check_heap();
a61af66fc99e Initial load duke parents: diff changeset	1246 if (!silent) gclog_or_tty->print_cr("]");
a61af66fc99e Initial load duke parents: diff changeset	1247
a61af66fc99e Initial load duke parents: diff changeset	1248 _verify_in_progress = false;
a61af66fc99e Initial load duke parents: diff changeset	1249 }
a61af66fc99e Initial load duke parents: diff changeset	1250
a61af66fc99e Initial load duke parents: diff changeset	1251 // Oop verification (see MacroAssembler::verify_oop)
a61af66fc99e Initial load duke parents: diff changeset	1252
a61af66fc99e Initial load duke parents: diff changeset	1253 static uintptr_t _verify_oop_data[2] = {0, (uintptr_t)-1};
a61af66fc99e Initial load duke parents: diff changeset	1254 static uintptr_t _verify_klass_data[2] = {0, (uintptr_t)-1};
a61af66fc99e Initial load duke parents: diff changeset	1255
a61af66fc99e Initial load duke parents: diff changeset	1256
a61af66fc99e Initial load duke parents: diff changeset	1257 static void calculate_verify_data(uintptr_t verify_data[2],
a61af66fc99e Initial load duke parents: diff changeset	1258 HeapWord* low_boundary,
a61af66fc99e Initial load duke parents: diff changeset	1259 HeapWord* high_boundary) {
a61af66fc99e Initial load duke parents: diff changeset	1260 assert(low_boundary < high_boundary, "bad interval");
a61af66fc99e Initial load duke parents: diff changeset	1261
a61af66fc99e Initial load duke parents: diff changeset	1262 // decide which low-order bits we require to be clear:
a61af66fc99e Initial load duke parents: diff changeset	1263 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	1264 size_t min_object_size = CollectedHeap::min_fill_size();
0 a61af66fc99e Initial load duke parents: diff changeset	1265
a61af66fc99e Initial load duke parents: diff changeset	1266 // make an inclusive limit:
a61af66fc99e Initial load duke parents: diff changeset	1267 uintptr_t max = (uintptr_t)high_boundary - min_object_size*wordSize;
a61af66fc99e Initial load duke parents: diff changeset	1268 uintptr_t min = (uintptr_t)low_boundary;
a61af66fc99e Initial load duke parents: diff changeset	1269 assert(min < max, "bad interval");
a61af66fc99e Initial load duke parents: diff changeset	1270 uintptr_t diff = max ^ min;
a61af66fc99e Initial load duke parents: diff changeset	1271
a61af66fc99e Initial load duke parents: diff changeset	1272 // throw away enough low-order bits to make the diff vanish
a61af66fc99e Initial load duke parents: diff changeset	1273 uintptr_t mask = (uintptr_t)(-1);
a61af66fc99e Initial load duke parents: diff changeset	1274 while ((mask & diff) != 0)
a61af66fc99e Initial load duke parents: diff changeset	1275 mask <<= 1;
a61af66fc99e Initial load duke parents: diff changeset	1276 uintptr_t bits = (min & mask);
a61af66fc99e Initial load duke parents: diff changeset	1277 assert(bits == (max & mask), "correct mask");
a61af66fc99e Initial load duke parents: diff changeset	1278 // check an intermediate value between min and max, just to make sure:
a61af66fc99e Initial load duke parents: diff changeset	1279 assert(bits == ((min + (max-min)/2) & mask), "correct mask");
a61af66fc99e Initial load duke parents: diff changeset	1280
a61af66fc99e Initial load duke parents: diff changeset	1281 // require address alignment, too:
a61af66fc99e Initial load duke parents: diff changeset	1282 mask \|= (alignSize - 1);
a61af66fc99e Initial load duke parents: diff changeset	1283
a61af66fc99e Initial load duke parents: diff changeset	1284 if (!(verify_data[0] == 0 && verify_data[1] == (uintptr_t)-1)) {
a61af66fc99e Initial load duke parents: diff changeset	1285 assert(verify_data[0] == mask && verify_data[1] == bits, "mask stability");
a61af66fc99e Initial load duke parents: diff changeset	1286 }
a61af66fc99e Initial load duke parents: diff changeset	1287 verify_data[0] = mask;
a61af66fc99e Initial load duke parents: diff changeset	1288 verify_data[1] = bits;
a61af66fc99e Initial load duke parents: diff changeset	1289 }
a61af66fc99e Initial load duke parents: diff changeset	1290
a61af66fc99e Initial load duke parents: diff changeset	1291
a61af66fc99e Initial load duke parents: diff changeset	1292 // Oop verification (see MacroAssembler::verify_oop)
a61af66fc99e Initial load duke parents: diff changeset	1293 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1294
a61af66fc99e Initial load duke parents: diff changeset	1295 uintptr_t Universe::verify_oop_mask() {
a61af66fc99e Initial load duke parents: diff changeset	1296 MemRegion m = heap()->reserved_region();
a61af66fc99e Initial load duke parents: diff changeset	1297 calculate_verify_data(_verify_oop_data,
a61af66fc99e Initial load duke parents: diff changeset	1298 m.start(),
a61af66fc99e Initial load duke parents: diff changeset	1299 m.end());
a61af66fc99e Initial load duke parents: diff changeset	1300 return _verify_oop_data[0];
a61af66fc99e Initial load duke parents: diff changeset	1301 }
a61af66fc99e Initial load duke parents: diff changeset	1302
a61af66fc99e Initial load duke parents: diff changeset	1303
a61af66fc99e Initial load duke parents: diff changeset	1304
a61af66fc99e Initial load duke parents: diff changeset	1305 uintptr_t Universe::verify_oop_bits() {
a61af66fc99e Initial load duke parents: diff changeset	1306 verify_oop_mask();
a61af66fc99e Initial load duke parents: diff changeset	1307 return _verify_oop_data[1];
a61af66fc99e Initial load duke parents: diff changeset	1308 }
a61af66fc99e Initial load duke parents: diff changeset	1309
a61af66fc99e Initial load duke parents: diff changeset	1310
a61af66fc99e Initial load duke parents: diff changeset	1311 uintptr_t Universe::verify_klass_mask() {
a61af66fc99e Initial load duke parents: diff changeset	1312 /* $$$
a61af66fc99e Initial load duke parents: diff changeset	1313 // A klass can never live in the new space. Since the new and old
a61af66fc99e Initial load duke parents: diff changeset	1314 // spaces can change size, we must settle for bounds-checking against
a61af66fc99e Initial load duke parents: diff changeset	1315 // the bottom of the world, plus the smallest possible new and old
a61af66fc99e Initial load duke parents: diff changeset	1316 // space sizes that may arise during execution.
a61af66fc99e Initial load duke parents: diff changeset	1317 size_t min_new_size = Universe::new_size(); // in bytes
a61af66fc99e Initial load duke parents: diff changeset	1318 size_t min_old_size = Universe::old_size(); // in bytes
a61af66fc99e Initial load duke parents: diff changeset	1319 calculate_verify_data(_verify_klass_data,
a61af66fc99e Initial load duke parents: diff changeset	1320 (HeapWord*)((uintptr_t)_new_gen->low_boundary + min_new_size + min_old_size),
a61af66fc99e Initial load duke parents: diff changeset	1321 _perm_gen->high_boundary);
a61af66fc99e Initial load duke parents: diff changeset	1322 */
a61af66fc99e Initial load duke parents: diff changeset	1323 // Why doesn't the above just say that klass's always live in the perm
a61af66fc99e Initial load duke parents: diff changeset	1324 // gen? I'll see if that seems to work...
a61af66fc99e Initial load duke parents: diff changeset	1325 MemRegion permanent_reserved;
a61af66fc99e Initial load duke parents: diff changeset	1326 switch (Universe::heap()->kind()) {
a61af66fc99e Initial load duke parents: diff changeset	1327 default:
a61af66fc99e Initial load duke parents: diff changeset	1328 // ???: What if a CollectedHeap doesn't have a permanent generation?
a61af66fc99e Initial load duke parents: diff changeset	1329 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1330 break;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1331 case CollectedHeap::GenCollectedHeap:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1332 case CollectedHeap::G1CollectedHeap: {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1333 SharedHeap* sh = (SharedHeap*) Universe::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1334 permanent_reserved = sh->perm_gen()->reserved();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1335 break;
0 a61af66fc99e Initial load duke parents: diff changeset	1336 }
a61af66fc99e Initial load duke parents: diff changeset	1337 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	1338 case CollectedHeap::ParallelScavengeHeap: {
a61af66fc99e Initial load duke parents: diff changeset	1339 ParallelScavengeHeap* psh = (ParallelScavengeHeap*) Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	1340 permanent_reserved = psh->perm_gen()->reserved();
a61af66fc99e Initial load duke parents: diff changeset	1341 break;
a61af66fc99e Initial load duke parents: diff changeset	1342 }
a61af66fc99e Initial load duke parents: diff changeset	1343 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	1344 }
a61af66fc99e Initial load duke parents: diff changeset	1345 calculate_verify_data(_verify_klass_data,
a61af66fc99e Initial load duke parents: diff changeset	1346 permanent_reserved.start(),
a61af66fc99e Initial load duke parents: diff changeset	1347 permanent_reserved.end());
a61af66fc99e Initial load duke parents: diff changeset	1348
a61af66fc99e Initial load duke parents: diff changeset	1349 return _verify_klass_data[0];
a61af66fc99e Initial load duke parents: diff changeset	1350 }
a61af66fc99e Initial load duke parents: diff changeset	1351
a61af66fc99e Initial load duke parents: diff changeset	1352
a61af66fc99e Initial load duke parents: diff changeset	1353
a61af66fc99e Initial load duke parents: diff changeset	1354 uintptr_t Universe::verify_klass_bits() {
a61af66fc99e Initial load duke parents: diff changeset	1355 verify_klass_mask();
a61af66fc99e Initial load duke parents: diff changeset	1356 return _verify_klass_data[1];
a61af66fc99e Initial load duke parents: diff changeset	1357 }
a61af66fc99e Initial load duke parents: diff changeset	1358
a61af66fc99e Initial load duke parents: diff changeset	1359
a61af66fc99e Initial load duke parents: diff changeset	1360 uintptr_t Universe::verify_mark_mask() {
a61af66fc99e Initial load duke parents: diff changeset	1361 return markOopDesc::lock_mask_in_place;
a61af66fc99e Initial load duke parents: diff changeset	1362 }
a61af66fc99e Initial load duke parents: diff changeset	1363
a61af66fc99e Initial load duke parents: diff changeset	1364
a61af66fc99e Initial load duke parents: diff changeset	1365
a61af66fc99e Initial load duke parents: diff changeset	1366 uintptr_t Universe::verify_mark_bits() {
a61af66fc99e Initial load duke parents: diff changeset	1367 intptr_t mask = verify_mark_mask();
a61af66fc99e Initial load duke parents: diff changeset	1368 intptr_t bits = (intptr_t)markOopDesc::prototype();
a61af66fc99e Initial load duke parents: diff changeset	1369 assert((bits & ~mask) == 0, "no stray header bits");
a61af66fc99e Initial load duke parents: diff changeset	1370 return bits;
a61af66fc99e Initial load duke parents: diff changeset	1371 }
a61af66fc99e Initial load duke parents: diff changeset	1372 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1373
a61af66fc99e Initial load duke parents: diff changeset	1374
a61af66fc99e Initial load duke parents: diff changeset	1375 void Universe::compute_verify_oop_data() {
a61af66fc99e Initial load duke parents: diff changeset	1376 verify_oop_mask();
a61af66fc99e Initial load duke parents: diff changeset	1377 verify_oop_bits();
a61af66fc99e Initial load duke parents: diff changeset	1378 verify_mark_mask();
a61af66fc99e Initial load duke parents: diff changeset	1379 verify_mark_bits();
a61af66fc99e Initial load duke parents: diff changeset	1380 verify_klass_mask();
a61af66fc99e Initial load duke parents: diff changeset	1381 verify_klass_bits();
a61af66fc99e Initial load duke parents: diff changeset	1382 }
a61af66fc99e Initial load duke parents: diff changeset	1383
a61af66fc99e Initial load duke parents: diff changeset	1384
a61af66fc99e Initial load duke parents: diff changeset	1385 void CommonMethodOopCache::init(klassOop k, methodOop m, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	1386 if (!UseSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	1387 _klass = k;
a61af66fc99e Initial load duke parents: diff changeset	1388 }
a61af66fc99e Initial load duke parents: diff changeset	1389 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1390 else {
a61af66fc99e Initial load duke parents: diff changeset	1391 // sharing initilization should have already set up _klass
a61af66fc99e Initial load duke parents: diff changeset	1392 assert(_klass != NULL, "just checking");
a61af66fc99e Initial load duke parents: diff changeset	1393 }
a61af66fc99e Initial load duke parents: diff changeset	1394 #endif
a61af66fc99e Initial load duke parents: diff changeset	1395
a61af66fc99e Initial load duke parents: diff changeset	1396 _method_idnum = m->method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	1397 assert(_method_idnum >= 0, "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1398 }
a61af66fc99e Initial load duke parents: diff changeset	1399
a61af66fc99e Initial load duke parents: diff changeset	1400
a61af66fc99e Initial load duke parents: diff changeset	1401 ActiveMethodOopsCache::~ActiveMethodOopsCache() {
a61af66fc99e Initial load duke parents: diff changeset	1402 if (_prev_methods != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1403 for (int i = _prev_methods->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	1404 jweak method_ref = _prev_methods->at(i);
a61af66fc99e Initial load duke parents: diff changeset	1405 if (method_ref != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1406 JNIHandles::destroy_weak_global(method_ref);
a61af66fc99e Initial load duke parents: diff changeset	1407 }
a61af66fc99e Initial load duke parents: diff changeset	1408 }
a61af66fc99e Initial load duke parents: diff changeset	1409 delete _prev_methods;
a61af66fc99e Initial load duke parents: diff changeset	1410 _prev_methods = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1411 }
a61af66fc99e Initial load duke parents: diff changeset	1412 }
a61af66fc99e Initial load duke parents: diff changeset	1413
a61af66fc99e Initial load duke parents: diff changeset	1414
a61af66fc99e Initial load duke parents: diff changeset	1415 void ActiveMethodOopsCache::add_previous_version(const methodOop method) {
a61af66fc99e Initial load duke parents: diff changeset	1416 assert(Thread::current()->is_VM_thread(),
a61af66fc99e Initial load duke parents: diff changeset	1417 "only VMThread can add previous versions");
a61af66fc99e Initial load duke parents: diff changeset	1418
a61af66fc99e Initial load duke parents: diff changeset	1419 if (_prev_methods == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1420 // This is the first previous version so make some space.
a61af66fc99e Initial load duke parents: diff changeset	1421 // Start with 2 elements under the assumption that the class
a61af66fc99e Initial load duke parents: diff changeset	1422 // won't be redefined much.
a61af66fc99e Initial load duke parents: diff changeset	1423 _prev_methods = new (ResourceObj::C_HEAP) GrowableArray<jweak>(2, true);
a61af66fc99e Initial load duke parents: diff changeset	1424 }
a61af66fc99e Initial load duke parents: diff changeset	1425
a61af66fc99e Initial load duke parents: diff changeset	1426 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	1427 RC_TRACE(0x00000100,
a61af66fc99e Initial load duke parents: diff changeset	1428 ("add: %s(%s): adding prev version ref for cached method @%d",
a61af66fc99e Initial load duke parents: diff changeset	1429 method->name()->as_C_string(), method->signature()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	1430 _prev_methods->length()));
a61af66fc99e Initial load duke parents: diff changeset	1431
a61af66fc99e Initial load duke parents: diff changeset	1432 methodHandle method_h(method);
a61af66fc99e Initial load duke parents: diff changeset	1433 jweak method_ref = JNIHandles::make_weak_global(method_h);
a61af66fc99e Initial load duke parents: diff changeset	1434 _prev_methods->append(method_ref);
a61af66fc99e Initial load duke parents: diff changeset	1435
a61af66fc99e Initial load duke parents: diff changeset	1436 // Using weak references allows previous versions of the cached
a61af66fc99e Initial load duke parents: diff changeset	1437 // method to be GC'ed when they are no longer needed. Since the
a61af66fc99e Initial load duke parents: diff changeset	1438 // caller is the VMThread and we are at a safepoint, this is a good
a61af66fc99e Initial load duke parents: diff changeset	1439 // time to clear out unused weak references.
a61af66fc99e Initial load duke parents: diff changeset	1440
a61af66fc99e Initial load duke parents: diff changeset	1441 for (int i = _prev_methods->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	1442 jweak method_ref = _prev_methods->at(i);
a61af66fc99e Initial load duke parents: diff changeset	1443 assert(method_ref != NULL, "weak method ref was unexpectedly cleared");
a61af66fc99e Initial load duke parents: diff changeset	1444 if (method_ref == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1445 _prev_methods->remove_at(i);
a61af66fc99e Initial load duke parents: diff changeset	1446 // Since we are traversing the array backwards, we don't have to
a61af66fc99e Initial load duke parents: diff changeset	1447 // do anything special with the index.
a61af66fc99e Initial load duke parents: diff changeset	1448 continue; // robustness
a61af66fc99e Initial load duke parents: diff changeset	1449 }
a61af66fc99e Initial load duke parents: diff changeset	1450
a61af66fc99e Initial load duke parents: diff changeset	1451 methodOop m = (methodOop)JNIHandles::resolve(method_ref);
a61af66fc99e Initial load duke parents: diff changeset	1452 if (m == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1453 // this method entry has been GC'ed so remove it
a61af66fc99e Initial load duke parents: diff changeset	1454 JNIHandles::destroy_weak_global(method_ref);
a61af66fc99e Initial load duke parents: diff changeset	1455 _prev_methods->remove_at(i);
a61af66fc99e Initial load duke parents: diff changeset	1456 } else {
a61af66fc99e Initial load duke parents: diff changeset	1457 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	1458 RC_TRACE(0x00000400, ("add: %s(%s): previous cached method @%d is alive",
a61af66fc99e Initial load duke parents: diff changeset	1459 m->name()->as_C_string(), m->signature()->as_C_string(), i));
a61af66fc99e Initial load duke parents: diff changeset	1460 }
a61af66fc99e Initial load duke parents: diff changeset	1461 }
a61af66fc99e Initial load duke parents: diff changeset	1462 } // end add_previous_version()
a61af66fc99e Initial load duke parents: diff changeset	1463
a61af66fc99e Initial load duke parents: diff changeset	1464
a61af66fc99e Initial load duke parents: diff changeset	1465 bool ActiveMethodOopsCache::is_same_method(const methodOop method) const {
a61af66fc99e Initial load duke parents: diff changeset	1466 instanceKlass* ik = instanceKlass::cast(klass());
a61af66fc99e Initial load duke parents: diff changeset	1467 methodOop check_method = ik->method_with_idnum(method_idnum());
a61af66fc99e Initial load duke parents: diff changeset	1468 assert(check_method != NULL, "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1469 if (check_method == method) {
a61af66fc99e Initial load duke parents: diff changeset	1470 // done with the easy case
a61af66fc99e Initial load duke parents: diff changeset	1471 return true;
a61af66fc99e Initial load duke parents: diff changeset	1472 }
a61af66fc99e Initial load duke parents: diff changeset	1473
a61af66fc99e Initial load duke parents: diff changeset	1474 if (_prev_methods != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1475 // The cached method has been redefined at least once so search
a61af66fc99e Initial load duke parents: diff changeset	1476 // the previous versions for a match.
a61af66fc99e Initial load duke parents: diff changeset	1477 for (int i = 0; i < _prev_methods->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1478 jweak method_ref = _prev_methods->at(i);
a61af66fc99e Initial load duke parents: diff changeset	1479 assert(method_ref != NULL, "weak method ref was unexpectedly cleared");
a61af66fc99e Initial load duke parents: diff changeset	1480 if (method_ref == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1481 continue; // robustness
a61af66fc99e Initial load duke parents: diff changeset	1482 }
a61af66fc99e Initial load duke parents: diff changeset	1483
a61af66fc99e Initial load duke parents: diff changeset	1484 check_method = (methodOop)JNIHandles::resolve(method_ref);
a61af66fc99e Initial load duke parents: diff changeset	1485 if (check_method == method) {
a61af66fc99e Initial load duke parents: diff changeset	1486 // a previous version matches
a61af66fc99e Initial load duke parents: diff changeset	1487 return true;
a61af66fc99e Initial load duke parents: diff changeset	1488 }
a61af66fc99e Initial load duke parents: diff changeset	1489 }
a61af66fc99e Initial load duke parents: diff changeset	1490 }
a61af66fc99e Initial load duke parents: diff changeset	1491
a61af66fc99e Initial load duke parents: diff changeset	1492 // either no previous versions or no previous version matched
a61af66fc99e Initial load duke parents: diff changeset	1493 return false;
a61af66fc99e Initial load duke parents: diff changeset	1494 }
a61af66fc99e Initial load duke parents: diff changeset	1495
a61af66fc99e Initial load duke parents: diff changeset	1496
a61af66fc99e Initial load duke parents: diff changeset	1497 methodOop LatestMethodOopCache::get_methodOop() {
a61af66fc99e Initial load duke parents: diff changeset	1498 instanceKlass* ik = instanceKlass::cast(klass());
a61af66fc99e Initial load duke parents: diff changeset	1499 methodOop m = ik->method_with_idnum(method_idnum());
a61af66fc99e Initial load duke parents: diff changeset	1500 assert(m != NULL, "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	1501 return m;
a61af66fc99e Initial load duke parents: diff changeset	1502 }
a61af66fc99e Initial load duke parents: diff changeset	1503
a61af66fc99e Initial load duke parents: diff changeset	1504
a61af66fc99e Initial load duke parents: diff changeset	1505 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1506 // Release dummy object(s) at bottom of heap
a61af66fc99e Initial load duke parents: diff changeset	1507 bool Universe::release_fullgc_alot_dummy() {
a61af66fc99e Initial load duke parents: diff changeset	1508 MutexLocker ml(FullGCALot_lock);
a61af66fc99e Initial load duke parents: diff changeset	1509 if (_fullgc_alot_dummy_array != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1510 if (_fullgc_alot_dummy_next >= _fullgc_alot_dummy_array->length()) {
a61af66fc99e Initial load duke parents: diff changeset	1511 // No more dummies to release, release entire array instead
a61af66fc99e Initial load duke parents: diff changeset	1512 _fullgc_alot_dummy_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1513 return false;
a61af66fc99e Initial load duke parents: diff changeset	1514 }
a61af66fc99e Initial load duke parents: diff changeset	1515 if (!UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	1516 // Release dummy at bottom of old generation
a61af66fc99e Initial load duke parents: diff changeset	1517 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL);
a61af66fc99e Initial load duke parents: diff changeset	1518 }
a61af66fc99e Initial load duke parents: diff changeset	1519 // Release dummy at bottom of permanent generation
a61af66fc99e Initial load duke parents: diff changeset	1520 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL);
a61af66fc99e Initial load duke parents: diff changeset	1521 }
a61af66fc99e Initial load duke parents: diff changeset	1522 return true;
a61af66fc99e Initial load duke parents: diff changeset	1523 }
a61af66fc99e Initial load duke parents: diff changeset	1524
a61af66fc99e Initial load duke parents: diff changeset	1525 #endif // ASSERT

Mercurial > hg > graal-compiler

annotate src/share/vm/memory/universe.cpp @ 1721:413ad0331a0c