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

comparison src/share/vm/oops/constantPool.cpp @ 10408:836a62f43af9

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

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	89e4d67fdd2a a1ebd310d5c1
children	6b0fd0964b87

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 #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);
 // Allocate read-write but may be able to move to read-only at dumping time
 // if all the klasses are resolved.  The only other field that is writable is
 // the resolved_references array, which is recreated at startup time.
 // But that could be moved to InstanceKlass (although a pain to access from
 // assembly code).  Maybe it could be moved to the cpCache which is RW.
-return new (loader_data, size, false, THREAD) ConstantPool(tags);
+return new (loader_data, size, false, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);
 }
 ConstantPool::ConstantPool(Array<u1>* tags) {
 set_length(tags->length());
 set_tags(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.
 for (int i = 0; i< reference_map()->length(); i++) {
 // 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;
 {
-MonitorLockerEx ml(this_oop->lock());
+oop cplock = 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 {
-MonitorLockerEx ml(this_oop->lock());
+oop cplock = 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();
-MonitorLockerEx ml(this_oop->lock());  // lock cpool to change tag.
+oop cplock = this_oop->lock();
+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);
-MonitorLockerEx ml(this_oop->lock());  // don't know if we really need this
+oop cplock = this_oop->lock();
+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.
 }
 } break;
 case JVM_CONSTANT_InvokeDynamic:
 {
-int k1 = invoke_dynamic_bootstrap_method_ref_index_at(index1);
+int k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
-int k2 = cp2->invoke_dynamic_bootstrap_method_ref_index_at(index2);
+int k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
-bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
+int i1 = invoke_dynamic_bootstrap_specifier_index(index1);
-if (!match)  return false;
+int i2 = cp2->invoke_dynamic_bootstrap_specifier_index(index2);
-k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
+// separate statements and variables because CHECK_false is used
-k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
+bool match_entry = compare_entry_to(k1, cp2, k2, CHECK_false);
-match = compare_entry_to(k1, cp2, k2, CHECK_false);
+bool match_operand = compare_operand_to(i1, cp2, i2, CHECK_false);
-if (!match)  return false;
+return (match_entry && match_operand);
-int argc = invoke_dynamic_argument_count_at(index1);
-if (argc == cp2->invoke_dynamic_argument_count_at(index2)) {
-for (int j = 0; j < argc; j++) {
-k1 = invoke_dynamic_argument_index_at(index1, j);
-k2 = cp2->invoke_dynamic_argument_index_at(index2, j);
-match = compare_entry_to(k1, cp2, k2, CHECK_false);
-if (!match)  return false;
-}
-return true;           // got through loop; all elements equal
-}
 } break;
 case JVM_CONSTANT_String:
 {
 Symbol* s1 = unresolved_string_at(index1);
 break;
 }
 return false;
 } // end compare_entry_to()
+// Resize the operands array with delta_len and delta_size.
+// Used in RedefineClasses for CP merge.
+void ConstantPool::resize_operands(int delta_len, int delta_size, TRAPS) {
+int old_len  = operand_array_length(operands());
+int new_len  = old_len + delta_len;
+int min_len  = (delta_len > 0) ? old_len : new_len;
+int old_size = operands()->length();
+int new_size = old_size + delta_size;
+int min_size = (delta_size > 0) ? old_size : new_size;
+ClassLoaderData* loader_data = pool_holder()->class_loader_data();
+Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, new_size, CHECK);
+// Set index in the resized array for existing elements only
+for (int idx = 0; idx < min_len; idx++) {
+int offset = operand_offset_at(idx);                       // offset in original array
+operand_offset_at_put(new_ops, idx, offset + 2*delta_len); // offset in resized array
+}
+// Copy the bootstrap specifiers only
+Copy::conjoint_memory_atomic(operands()->adr_at(2*old_len),
+new_ops->adr_at(2*new_len),
+(min_size - 2*min_len) * sizeof(u2));
+// Explicitly deallocate old operands array.
+// Note, it is not needed for 7u backport.
+if ( operands() != NULL) { // the safety check
+MetadataFactory::free_array<u2>(loader_data, operands());
+}
+set_operands(new_ops);
+} // end resize_operands()
+// Extend the operands array with the length and size of the ext_cp operands.
+// Used in RedefineClasses for CP merge.
+void ConstantPool::extend_operands(constantPoolHandle ext_cp, TRAPS) {
+int delta_len = operand_array_length(ext_cp->operands());
+if (delta_len == 0) {
+return; // nothing to do
+}
+int delta_size = ext_cp->operands()->length();
+assert(delta_len  > 0 && delta_size > 0, "extended operands array must be bigger");
+if (operand_array_length(operands()) == 0) {
+ClassLoaderData* loader_data = pool_holder()->class_loader_data();
+Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, delta_size, CHECK);
+// The first element index defines the offset of second part
+operand_offset_at_put(new_ops, 0, 2*delta_len); // offset in new array
+set_operands(new_ops);
+} else {
+resize_operands(delta_len, delta_size, CHECK);
+}
+} // end extend_operands()
+// Shrink the operands array to a smaller array with new_len length.
+// Used in RedefineClasses for CP merge.
+void ConstantPool::shrink_operands(int new_len, TRAPS) {
+int old_len = operand_array_length(operands());
+if (new_len == old_len) {
+return; // nothing to do
+}
+assert(new_len < old_len, "shrunken operands array must be smaller");
+int free_base  = operand_next_offset_at(new_len - 1);
+int delta_len  = new_len - old_len;
+int delta_size = 2*delta_len + free_base - operands()->length();
+resize_operands(delta_len, delta_size, CHECK);
+} // end shrink_operands()
 void ConstantPool::copy_operands(constantPoolHandle from_cp,
 constantPoolHandle to_cp,
 TRAPS) {
 return 0;  // entry not found; return unused index zero (0)
 } // end find_matching_entry()
+// Compare this constant pool's bootstrap specifier at idx1 to the constant pool
+// cp2's bootstrap specifier at idx2.
+bool ConstantPool::compare_operand_to(int idx1, constantPoolHandle cp2, int idx2, TRAPS) {
+int k1 = operand_bootstrap_method_ref_index_at(idx1);
+int k2 = cp2->operand_bootstrap_method_ref_index_at(idx2);
+bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
+if (!match) {
+return false;
+}
+int argc = operand_argument_count_at(idx1);
+if (argc == cp2->operand_argument_count_at(idx2)) {
+for (int j = 0; j < argc; j++) {
+k1 = operand_argument_index_at(idx1, j);
+k2 = cp2->operand_argument_index_at(idx2, j);
+match = compare_entry_to(k1, cp2, k2, CHECK_false);
+if (!match) {
+return false;
+}
+}
+return true;           // got through loop; all elements equal
+}
+return false;
+} // end compare_operand_to()
+// Search constant pool search_cp for a bootstrap specifier that matches
+// this constant pool's bootstrap specifier at pattern_i index.
+// Return the index of a matching bootstrap specifier or (-1) if there is no match.
+int ConstantPool::find_matching_operand(int pattern_i,
+constantPoolHandle search_cp, int search_len, TRAPS) {
+for (int i = 0; i < search_len; i++) {
+bool found = compare_operand_to(pattern_i, search_cp, i, CHECK_(-1));
+if (found) {
+return i;
+}
+}
+return -1;  // bootstrap specifier not found; return unused index (-1)
+} // end find_matching_operand()
 #ifndef PRODUCT
 const char* ConstantPool::printable_name_at(int which) {
 constantTag tag = tag_at(which);

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/constantPool.cpp @ 10408:836a62f43af9