graal-jvmci-8: src/share/vm/oops/constantPool.cpp comparison

comparison src/share/vm/oops/constantPool.cpp @ 13086:096c224171c4

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

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 20 Nov 2013 00:10:38 +0100
parents	cefad50507d8 b8860472c377
children	d8041d695d19

comparison

equal deleted inserted replaced

-:92b7ec34ddfa
+:096c224171c4
 #include "oops/objArrayKlass.hpp"
 #include "runtime/fieldType.hpp"
 #include "runtime/init.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/signature.hpp"
-#include "runtime/synchronizer.hpp"
 #include "runtime/vframe.hpp"
 ConstantPool* ConstantPool::allocate(ClassLoaderData* loader_data, int length, TRAPS) {
 // Tags are RW but comment below applies to tags also.
 Array<u1>* tags = MetadataFactory::new_writeable_array<u1>(loader_data, length, 0, CHECK_NULL);
 set_pool_holder(NULL);
 set_flags(0);
 // only set to non-zero if constant pool is merged by RedefineClasses
 set_version(0);
+set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));
 // initialize tag array
 int length = tags->length();
 for (int index = 0; index < length; index++) {
 tags->at_put(index, JVM_CONSTANT_Invalid);
 }
 void ConstantPool::release_C_heap_structures() {
 // walk constant pool and decrement symbol reference counts
 unreference_symbols();
+delete _lock;
+set_lock(NULL);
 }
 objArrayOop ConstantPool::resolved_references() const {
 return (objArrayOop)JNIHandles::resolve(_resolved_references);
 }
 Handle refs_handle (THREAD, (oop)stom);  // must handleize.
 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
 set_resolved_references(loader_data->add_handle(refs_handle));
 }
+// Also need to recreate the mutex.  Make sure this matches the constructor
+set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));
 }
 }
 void ConstantPool::remove_unshareable_info() {
 // Resolved references are not in the shared archive.
 // Save the length for restoration.  It is not necessarily the same length
 // as reference_map.length() if invokedynamic is saved.
 set_resolved_reference_length(
 resolved_references() != NULL ? resolved_references()->length() : 0);
 set_resolved_references(NULL);
-}
+set_lock(NULL);
-oop ConstantPool::lock() {
-if (_pool_holder) {
-// We re-use the _pool_holder's init_lock to reduce footprint.
-// Notes on deadlocks:
-// [1] This lock is a Java oop, so it can be recursively locked by
-//     the same thread without self-deadlocks.
-// [2] Deadlock will happen if there is circular dependency between
-//     the <clinit> of two Java classes. However, in this case,
-//     the deadlock would have happened long before we reach
-//     ConstantPool::lock(), so reusing init_lock does not
-//     increase the possibility of deadlock.
-return _pool_holder->init_lock();
-} else {
-return NULL;
-}
 }
 int ConstantPool::cp_to_object_index(int cp_index) {
 // this is harder don't do this so much.
 int i = reference_map()->find(cp_index);
 // until the loader_data is registered.
 Handle mirror_handle;
 Symbol* name = NULL;
 Handle       loader;
-{
+{  MonitorLockerEx ml(this_oop->lock());
-oop cplock = this_oop->lock();
-ObjectLocker ol(cplock , THREAD, cplock != NULL);
 if (this_oop->tag_at(which).is_unresolved_klass()) {
 if (this_oop->tag_at(which).is_unresolved_klass_in_error()) {
 in_error = true;
 } else {
 ResourceMark rm;
 Symbol* error = PENDING_EXCEPTION->klass()->name();
 bool throw_orig_error = false;
 {
-oop cplock = this_oop->lock();
+MonitorLockerEx ml(this_oop->lock());
-ObjectLocker ol(cplock, THREAD, cplock != NULL);
 // some other thread has beaten us and has resolved the class.
 if (this_oop->tag_at(which).is_klass()) {
 CLEAR_PENDING_EXCEPTION;
 entry = this_oop->resolved_klass_at(which);
 InstanceKlass::cast(k())->external_name());
 }
 }
 return k();
 } else {
-oop cplock = this_oop->lock();
+MonitorLockerEx ml(this_oop->lock());
-ObjectLocker ol(cplock, THREAD, cplock != NULL);
 // Only updated constant pool - if it is resolved.
 do_resolve = this_oop->tag_at(which).is_unresolved_klass();
 if (do_resolve) {
 ClassLoaderData* this_key = this_oop->pool_holder()->class_loader_data();
 this_key->record_dependency(k(), CHECK_NULL); // Can throw OOM
 // in the resolution error table, so that the same exception is thrown again.
 void ConstantPool::save_and_throw_exception(constantPoolHandle this_oop, int which,
 int tag, TRAPS) {
 ResourceMark rm;
 Symbol* error = PENDING_EXCEPTION->klass()->name();
-oop cplock = this_oop->lock();
+MonitorLockerEx ml(this_oop->lock());  // lock cpool to change tag.
-ObjectLocker ol(cplock, THREAD, cplock != NULL);  // lock cpool to change tag.
 int error_tag = (tag == JVM_CONSTANT_MethodHandle) ?
 JVM_CONSTANT_MethodHandleInError : JVM_CONSTANT_MethodTypeInError;
 if (!PENDING_EXCEPTION->
 }
 if (cache_index >= 0) {
 // Cache the oop here also.
 Handle result_handle(THREAD, result_oop);
-oop cplock = this_oop->lock();
+MonitorLockerEx ml(this_oop->lock());  // don't know if we really need this
-ObjectLocker ol(cplock, THREAD, cplock != NULL);  // don't know if we really need this
 oop result = this_oop->resolved_references()->obj_at(cache_index);
 // Benign race condition:  resolved_references may already be filled in while we were trying to lock.
 // The important thing here is that all threads pick up the same result.
 // It doesn't matter which racing thread wins, as long as only one
 // result is used by all threads, and all future queries.
 // Compare this constant pool's entry at index1 to the constant pool
 // cp2's entry at index2.
 bool ConstantPool::compare_entry_to(int index1, constantPoolHandle cp2,
 int index2, TRAPS) {
-jbyte t1 = tag_at(index1).value();
+// The error tags are equivalent to non-error tags when comparing
-jbyte t2 = cp2->tag_at(index2).value();
+jbyte t1 = tag_at(index1).non_error_value();
+jbyte t2 = cp2->tag_at(index2).non_error_value();
-// JVM_CONSTANT_UnresolvedClassInError is equal to JVM_CONSTANT_UnresolvedClass
-// when comparing
-if (t1 == JVM_CONSTANT_UnresolvedClassInError) {
-t1 = JVM_CONSTANT_UnresolvedClass;
-}
-if (t2 == JVM_CONSTANT_UnresolvedClassInError) {
-t2 = JVM_CONSTANT_UnresolvedClass;
-}
 if (t1 != t2) {
 // Not the same entry type so there is nothing else to check. Note
 // that this style of checking will consider resolved/unresolved
 // class pairs as different.
 }
 } break;
 case JVM_CONSTANT_MethodType:
 {
-int k1 = method_type_index_at(index1);
+int k1 = method_type_index_at_error_ok(index1);
-int k2 = cp2->method_type_index_at(index2);
+int k2 = cp2->method_type_index_at_error_ok(index2);
 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
 if (match) {
 return true;
 }
 } break;
 case JVM_CONSTANT_MethodHandle:
 {
-int k1 = method_handle_ref_kind_at(index1);
+int k1 = method_handle_ref_kind_at_error_ok(index1);
-int k2 = cp2->method_handle_ref_kind_at(index2);
+int k2 = cp2->method_handle_ref_kind_at_error_ok(index2);
 if (k1 == k2) {
-int i1 = method_handle_index_at(index1);
+int i1 = method_handle_index_at_error_ok(index1);
-int i2 = cp2->method_handle_index_at(index2);
+int i2 = cp2->method_handle_index_at_error_ok(index2);
 bool match = compare_entry_to(i1, cp2, i2, CHECK_false);
 if (match) {
 return true;
 }
 }
 } else {
 to_cp->unresolved_klass_at_put(to_i, entry.get_symbol());
 }
 } break;
-case JVM_CONSTANT_UnresolvedClassInError:
-{
-Symbol* k = from_cp->unresolved_klass_at(from_i);
-to_cp->unresolved_klass_at_put(to_i, k);
-to_cp->tag_at_put(to_i, JVM_CONSTANT_UnresolvedClassInError);
-} break;
 case JVM_CONSTANT_String:
 {
 Symbol* s = from_cp->unresolved_string_at(from_i);
 to_cp->unresolved_string_at_put(to_i, s);
 } break;
 s->increment_refcount();
 to_cp->symbol_at_put(to_i, s);
 } break;
 case JVM_CONSTANT_MethodType:
-{
+case JVM_CONSTANT_MethodTypeInError:
-jint k = from_cp->method_type_index_at(from_i);
+{
+jint k = from_cp->method_type_index_at_error_ok(from_i);
 to_cp->method_type_index_at_put(to_i, k);
 } break;
 case JVM_CONSTANT_MethodHandle:
-{
+case JVM_CONSTANT_MethodHandleInError:
-int k1 = from_cp->method_handle_ref_kind_at(from_i);
+{
-int k2 = from_cp->method_handle_index_at(from_i);
+int k1 = from_cp->method_handle_ref_kind_at_error_ok(from_i);
+int k2 = from_cp->method_handle_index_at_error_ok(from_i);
 to_cp->method_handle_index_at_put(to_i, k1, k2);
 } break;
 case JVM_CONSTANT_InvokeDynamic:
 {

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/oops/constantPool.cpp @ 13086:096c224171c4