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

comparison src/share/vm/memory/universe.cpp @ 11173:6b0fd0964b87

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 31 Jul 2013 11:00:54 +0200
parents	836a62f43af9 71180a6e5080
children	3cce976666d9

comparison

equal deleted inserted replaced

-:4ea54634f03e
+:6b0fd0964b87
 #include "oops/instanceMirrorKlass.hpp"
 #include "oops/instanceRefKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/typeArrayKlass.hpp"
 #include "prims/jvmtiRedefineClassesTrace.hpp"
-#include "runtime/aprofiler.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/fprofiler.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/init.hpp"
 Array<Klass*>* Universe::_the_array_interfaces_array = NULL;
 oop Universe::_the_null_string                        = NULL;
 oop Universe::_the_min_jint_string                   = NULL;
 LatestMethodOopCache* Universe::_finalizer_register_cache = NULL;
 LatestMethodOopCache* Universe::_loader_addClass_cache    = NULL;
+LatestMethodOopCache* Universe::_pd_implies_cache         = NULL;
 ActiveMethodOopsCache* Universe::_reflect_invoke_cache    = NULL;
 oop Universe::_out_of_memory_error_java_heap          = NULL;
-oop Universe::_out_of_memory_error_perm_gen           = NULL;
+oop Universe::_out_of_memory_error_metaspace          = NULL;
+oop Universe::_out_of_memory_error_class_metaspace    = NULL;
 oop Universe::_out_of_memory_error_array_size         = NULL;
 oop Universe::_out_of_memory_error_gc_overhead_limit  = NULL;
 objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL;
 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0;
 bool Universe::_verify_in_progress                    = false;
 f->do_oop((oop*)&_the_empty_class_klass_array);
 f->do_oop((oop*)&_the_null_string);
 f->do_oop((oop*)&_the_min_jint_string);
 f->do_oop((oop*)&_out_of_memory_error_java_heap);
-f->do_oop((oop*)&_out_of_memory_error_perm_gen);
+f->do_oop((oop*)&_out_of_memory_error_metaspace);
+f->do_oop((oop*)&_out_of_memory_error_class_metaspace);
 f->do_oop((oop*)&_out_of_memory_error_array_size);
 f->do_oop((oop*)&_out_of_memory_error_gc_overhead_limit);
 f->do_oop((oop*)&_preallocated_out_of_memory_error_array);
 f->do_oop((oop*)&_null_ptr_exception_instance);
 f->do_oop((oop*)&_arithmetic_exception_instance);
 f->do_ptr((void**)&_the_empty_method_array);
 f->do_ptr((void**)&_the_empty_klass_array);
 _finalizer_register_cache->serialize(f);
 _loader_addClass_cache->serialize(f);
 _reflect_invoke_cache->serialize(f);
+_pd_implies_cache->serialize(f);
 }
 void Universe::check_alignment(uintx size, uintx alignment, const char* name) {
 if (size < alignment || size % alignment != 0) {
 vm_exit_during_initialization(
 Klass* ko = k_h();
 klassVtable* vt = ko->vtable();
 if (vt) vt->initialize_vtable(false, CHECK);
 if (ko->oop_is_instance()) {
 InstanceKlass* ik = (InstanceKlass*)ko;
-for (KlassHandle s_h(THREAD, ik->subklass()); s_h() != NULL; s_h = (THREAD, s_h()->next_sibling())) {
+for (KlassHandle s_h(THREAD, ik->subklass());
+s_h() != NULL;
+s_h = KlassHandle(THREAD, s_h()->next_sibling())) {
 reinitialize_vtable_of(s_h, CHECK);
 }
 }
 }
 // backtrace. These errors are kept alive forever and may be "re-used" when all
 // preallocated errors with backtrace have been consumed. Also need to avoid
 // a potential loop which could happen if an out of memory occurs when attempting
 // to allocate the backtrace.
 return ((throwable() != Universe::_out_of_memory_error_java_heap) &&
-(throwable() != Universe::_out_of_memory_error_perm_gen)  &&
+(throwable() != Universe::_out_of_memory_error_metaspace)  &&
+(throwable() != Universe::_out_of_memory_error_class_metaspace)  &&
 (throwable() != Universe::_out_of_memory_error_array_size) &&
 (throwable() != Universe::_out_of_memory_error_gc_overhead_limit));
 }
 // We have a heap so create the Method* caches before
 // Metaspace::initialize_shared_spaces() tries to populate them.
 Universe::_finalizer_register_cache = new LatestMethodOopCache();
 Universe::_loader_addClass_cache    = new LatestMethodOopCache();
+Universe::_pd_implies_cache         = new LatestMethodOopCache();
 Universe::_reflect_invoke_cache     = new ActiveMethodOopsCache();
 if (UseSharedSpaces) {
 // Read the data structures supporting the shared spaces (shared
 // system dictionary, symbol table, etc.).  After that, access to
 // Setup preallocated OutOfMemoryError errors
 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_OutOfMemoryError(), true, CHECK_false);
 k_h = instanceKlassHandle(THREAD, k);
 Universe::_out_of_memory_error_java_heap = k_h->allocate_instance(CHECK_false);
-Universe::_out_of_memory_error_perm_gen = k_h->allocate_instance(CHECK_false);
+Universe::_out_of_memory_error_metaspace = k_h->allocate_instance(CHECK_false);
+Universe::_out_of_memory_error_class_metaspace = k_h->allocate_instance(CHECK_false);
 Universe::_out_of_memory_error_array_size = k_h->allocate_instance(CHECK_false);
 Universe::_out_of_memory_error_gc_overhead_limit =
 k_h->allocate_instance(CHECK_false);
 // Setup preallocated NullPointerException
 // We prefer to not handle this generally, so we always reinitialize these detail messages.
 Handle msg = java_lang_String::create_from_str("Java heap space", CHECK_false);
 java_lang_Throwable::set_message(Universe::_out_of_memory_error_java_heap, msg());
 msg = java_lang_String::create_from_str("Metadata space", CHECK_false);
-java_lang_Throwable::set_message(Universe::_out_of_memory_error_perm_gen, msg());
+java_lang_Throwable::set_message(Universe::_out_of_memory_error_metaspace, msg());
+msg = java_lang_String::create_from_str("Class Metadata space", CHECK_false);
+java_lang_Throwable::set_message(Universe::_out_of_memory_error_class_metaspace, msg());
 msg = java_lang_String::create_from_str("Requested array size exceeds VM limit", CHECK_false);
 java_lang_Throwable::set_message(Universe::_out_of_memory_error_array_size, msg());
 msg = java_lang_String::create_from_str("GC overhead limit exceeded", CHECK_false);
 "java.lang.ClassLoader.addClass", false);
 }
 Universe::_loader_addClass_cache->init(
 SystemDictionary::ClassLoader_klass(), m, CHECK_false);
+// Setup method for checking protection domain
+InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass())->link_class(CHECK_false);
+m = InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass())->
+find_method(vmSymbols::impliesCreateAccessControlContext_name(),
+vmSymbols::void_boolean_signature());
+// Allow NULL which should only happen with bootstrapping.
+if (m != NULL) {
+if (m->is_static()) {
+// NoSuchMethodException doesn't actually work because it tries to run the
+// <init> function before java_lang_Class is linked. Print error and exit.
+tty->print_cr("ProtectionDomain.impliesCreateAccessControlContext() has the wrong linkage");
+return false; // initialization failed
+}
+Universe::_pd_implies_cache->init(
+SystemDictionary::ProtectionDomain_klass(), m, CHECK_false);;
+}
 // The folowing is initializing converter functions for serialization in
 // JVM.cpp. If we clean up the StrictMath code above we may want to find
 // a better solution for this as well.
 initialize_converter_functions();
 // ("weak") refs processing infrastructure initialization
 Universe::heap()->post_initialize();
 // Initialize performance counters for metaspaces
 MetaspaceCounters::initialize_performance_counters();
+MemoryService::add_metaspace_memory_pools();
 GC_locker::unlock();  // allow gc after bootstrapping
 MemoryService::set_universe_heap(Universe::_collectedHeap);
 return true;
 return false;
 }
 Method* LatestMethodOopCache::get_Method() {
+if (klass() == NULL) return NULL;
 InstanceKlass* ik = InstanceKlass::cast(klass());
 Method* m = ik->method_with_idnum(method_idnum());
 assert(m != NULL, "sanity check");
 return m;
 }

Mercurial > hg > truffle

comparison src/share/vm/memory/universe.cpp @ 11173:6b0fd0964b87