jdk-sandbox: comparison hotspot/src/share/vm/oops/constantPool.cpp

equal deleted inserted replaced

-:4a0312f2894b
+:18e7896ca9fe
 int i = reference_map()->find(cp_index);
 // We might not find the index for jsr292 call.
 return (i < 0) ? _no_index_sentinel : i;
 }
-void ConstantPool::trace_class_resolution(constantPoolHandle this_cp, KlassHandle k) {
+void ConstantPool::trace_class_resolution(const constantPoolHandle& this_cp, KlassHandle k) {
 ResourceMark rm;
 int line_number = -1;
 const char * source_file = NULL;
 if (JavaThread::current()->has_last_Java_frame()) {
 // try to identify the method which called this function.
 if (k() != this_cp->pool_holder()) {
 // only print something if the classes are different
 if (source_file != NULL) {
 tty->print("RESOLVE %s %s %s:%d\n",
 this_cp->pool_holder()->external_name(),
-InstanceKlass::cast(k())->external_name(), source_file, line_number);
+k->external_name(), source_file, line_number);
 } else {
 tty->print("RESOLVE %s %s\n",
 this_cp->pool_holder()->external_name(),
-InstanceKlass::cast(k())->external_name());
+k->external_name());
 }
 }
 }
-Klass* ConstantPool::klass_at_impl(constantPoolHandle this_cp, int which,
+Klass* ConstantPool::klass_at_impl(const constantPoolHandle& this_cp, int which,
 bool save_resolution_error, TRAPS) {
 assert(THREAD->is_Java_thread(), "must be a Java thread");
 // A resolved constantPool entry will contain a Klass*, otherwise a Symbol*.
 // It is not safe to rely on the tag bit's here, since we don't have a lock, and
 // Make this class loader depend upon the class loader owning the class reference
 ClassLoaderData* this_key = this_cp->pool_holder()->class_loader_data();
 this_key->record_dependency(k(), CHECK_NULL); // Can throw OOM
-if (TraceClassResolution && !k->oop_is_array()) {
+if (TraceClassResolution && !k->is_array_klass()) {
 // skip resolving the constant pool so that this code gets
 // called the next time some bytecodes refer to this class.
 trace_class_resolution(this_cp, k);
 return k();
 } else {
 // Does not update ConstantPool* - to avoid any exception throwing. Used
 // by compiler and exception handling.  Also used to avoid classloads for
 // instanceof operations. Returns NULL if the class has not been loaded or
 // if the verification of constant pool failed
-Klass* ConstantPool::klass_at_if_loaded(constantPoolHandle this_cp, int which) {
+Klass* ConstantPool::klass_at_if_loaded(const constantPoolHandle& this_cp, int which) {
 CPSlot entry = this_cp->slot_at(which);
 if (entry.is_resolved()) {
 assert(entry.get_klass()->is_klass(), "must be");
 return entry.get_klass();
 } else {
 }
 }
 }
-Klass* ConstantPool::klass_ref_at_if_loaded(constantPoolHandle this_cp, int which) {
+Klass* ConstantPool::klass_ref_at_if_loaded(const constantPoolHandle& this_cp, int which) {
 return klass_at_if_loaded(this_cp, this_cp->klass_ref_index_at(which));
 }
-Method* ConstantPool::method_at_if_loaded(constantPoolHandle cpool,
+Method* ConstantPool::method_at_if_loaded(const constantPoolHandle& cpool,
 int which) {
 if (cpool->cache() == NULL)  return NULL;  // nothing to load yet
 int cache_index = decode_cpcache_index(which, true);
 if (!(cache_index >= 0 && cache_index < cpool->cache()->length())) {
 // FIXME: should be an assert
 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
 return e->method_if_resolved(cpool);
 }
-bool ConstantPool::has_appendix_at_if_loaded(constantPoolHandle cpool, int which) {
+bool ConstantPool::has_appendix_at_if_loaded(const constantPoolHandle& cpool, int which) {
 if (cpool->cache() == NULL)  return false;  // nothing to load yet
 int cache_index = decode_cpcache_index(which, true);
 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
 return e->has_appendix();
 }
-oop ConstantPool::appendix_at_if_loaded(constantPoolHandle cpool, int which) {
+oop ConstantPool::appendix_at_if_loaded(const constantPoolHandle& cpool, int which) {
 if (cpool->cache() == NULL)  return NULL;  // nothing to load yet
 int cache_index = decode_cpcache_index(which, true);
 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
 return e->appendix_if_resolved(cpool);
 }
-bool ConstantPool::has_method_type_at_if_loaded(constantPoolHandle cpool, int which) {
+bool ConstantPool::has_method_type_at_if_loaded(const constantPoolHandle& cpool, int which) {
 if (cpool->cache() == NULL)  return false;  // nothing to load yet
 int cache_index = decode_cpcache_index(which, true);
 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
 return e->has_method_type();
 }
-oop ConstantPool::method_type_at_if_loaded(constantPoolHandle cpool, int which) {
+oop ConstantPool::method_type_at_if_loaded(const constantPoolHandle& cpool, int which) {
 if (cpool->cache() == NULL)  return NULL;  // nothing to load yet
 int cache_index = decode_cpcache_index(which, true);
 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
 return e->method_type_if_resolved(cpool);
 }
 int member_index = cache()->entry_at(cpc_index)->constant_pool_index();
 return member_index;
 }
-void ConstantPool::verify_constant_pool_resolve(constantPoolHandle this_cp, KlassHandle k, TRAPS) {
+void ConstantPool::verify_constant_pool_resolve(const constantPoolHandle& this_cp, KlassHandle k, TRAPS) {
-if (k->oop_is_instance() || k->oop_is_objArray()) {
+if (k->is_instance_klass() || k->is_objArray_klass()) {
 instanceKlassHandle holder (THREAD, this_cp->pool_holder());
-Klass* elem = k->oop_is_instance() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
+Klass* elem = k->is_instance_klass() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
 KlassHandle element (THREAD, elem);
 // The element type could be a typeArray - we only need the access check if it is
 // an reference to another class
-if (element->oop_is_instance()) {
+if (element->is_instance_klass()) {
 LinkResolver::check_klass_accessability(holder, element, CHECK);
 }
 }
 }
 BasicType ConstantPool::basic_type_for_signature_at(int which) {
 return FieldType::basic_type(symbol_at(which));
 }
-void ConstantPool::resolve_string_constants_impl(constantPoolHandle this_cp, TRAPS) {
+void ConstantPool::resolve_string_constants_impl(const constantPoolHandle& this_cp, TRAPS) {
 for (int index = 1; index < this_cp->length(); index++) { // Index 0 is unused
 if (this_cp->tag_at(index).is_string()) {
 this_cp->string_at(index, CHECK);
 }
 }
 }
 // set_preresolution(); or some bit for future use
 return true;
 }
-Symbol* ConstantPool::exception_message(constantPoolHandle this_cp, int which, constantTag tag, oop pending_exception) {
+Symbol* ConstantPool::exception_message(const constantPoolHandle& this_cp, int which, constantTag tag, oop pending_exception) {
 // Dig out the detailed message to reuse if possible
 Symbol* message = java_lang_Throwable::detail_message(pending_exception);
 if (message != NULL) {
 return message;
 }
 }
 return message;
 }
-void ConstantPool::throw_resolution_error(constantPoolHandle this_cp, int which, TRAPS) {
+void ConstantPool::throw_resolution_error(const constantPoolHandle& this_cp, int which, TRAPS) {
 Symbol* message = NULL;
 Symbol* error = SystemDictionary::find_resolution_error(this_cp, which, &message);
 assert(error != NULL && message != NULL, "checking");
 CLEAR_PENDING_EXCEPTION;
 ResourceMark rm;
 THROW_MSG(error, message->as_C_string());
 }
 // If resolution for Class, MethodHandle or MethodType fails, save the exception
 // in the resolution error table, so that the same exception is thrown again.
-void ConstantPool::save_and_throw_exception(constantPoolHandle this_cp, int which,
+void ConstantPool::save_and_throw_exception(const constantPoolHandle& this_cp, int which,
 constantTag tag, TRAPS) {
 Symbol* error = PENDING_EXCEPTION->klass()->name();
 int error_tag = tag.error_value();
 }
 // Called to resolve constants in the constant pool and return an oop.
 // Some constant pool entries cache their resolved oop. This is also
 // called to create oops from constants to use in arguments for invokedynamic
-oop ConstantPool::resolve_constant_at_impl(constantPoolHandle this_cp, int index, int cache_index, TRAPS) {
+oop ConstantPool::resolve_constant_at_impl(const constantPoolHandle& this_cp, int index, int cache_index, TRAPS) {
 oop result_oop = NULL;
 Handle throw_exception;
 if (cache_index == _possible_index_sentinel) {
 // It is possible that this constant is one which is cached in the objects.
 assert(java_lang_String::is_instance(str), "must be string");
 return str;
 }
-oop ConstantPool::resolve_bootstrap_specifier_at_impl(constantPoolHandle this_cp, int index, TRAPS) {
+oop ConstantPool::resolve_bootstrap_specifier_at_impl(const constantPoolHandle& this_cp, int index, TRAPS) {
 assert(this_cp->tag_at(index).is_invoke_dynamic(), "Corrupted constant pool");
 Handle bsm;
 int argc;
 {
 }
 return info();
 }
-oop ConstantPool::string_at_impl(constantPoolHandle this_cp, int which, int obj_index, TRAPS) {
+oop ConstantPool::string_at_impl(const constantPoolHandle& this_cp, int which, int obj_index, TRAPS) {
 // If the string has already been interned, this entry will be non-null
 oop str = this_cp->resolved_references()->obj_at(obj_index);
 if (str != NULL) return str;
 Symbol* sym = this_cp->unresolved_string_at(which);
 str = StringTable::intern(sym, CHECK_(NULL));
 }
 // 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,
+bool ConstantPool::compare_entry_to(int index1, const constantPoolHandle& cp2,
 int index2, TRAPS) {
 // The error tags are equivalent to non-error tags when comparing
 jbyte t1 = tag_at(index1).non_error_value();
 jbyte t2 = cp2->tag_at(index2).non_error_value();
 } // 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) {
+void ConstantPool::extend_operands(const 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();
 resize_operands(delta_len, delta_size, CHECK);
 } // end shrink_operands()
-void ConstantPool::copy_operands(constantPoolHandle from_cp,
+void ConstantPool::copy_operands(const constantPoolHandle& from_cp,
-constantPoolHandle to_cp,
+const constantPoolHandle& to_cp,
 TRAPS) {
 int from_oplen = operand_array_length(from_cp->operands());
 int old_oplen  = operand_array_length(to_cp->operands());
 if (from_oplen != 0) {
 // Copy this constant pool's entries at start_i to end_i (inclusive)
 // to the constant pool to_cp's entries starting at to_i. A total of
 // (end_i - start_i) + 1 entries are copied.
-void ConstantPool::copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i,
+void ConstantPool::copy_cp_to_impl(const constantPoolHandle& from_cp, int start_i, int end_i,
-constantPoolHandle to_cp, int to_i, TRAPS) {
+const constantPoolHandle& to_cp, int to_i, TRAPS) {
 int dest_i = to_i;  // leave original alone for debug purposes
 for (int src_i = start_i; src_i <= end_i; /* see loop bottom */ ) {
 } // end copy_cp_to_impl()
 // Copy this constant pool's entry at from_i to the constant pool
 // to_cp's entry at to_i.
-void ConstantPool::copy_entry_to(constantPoolHandle from_cp, int from_i,
+void ConstantPool::copy_entry_to(const constantPoolHandle& from_cp, int from_i,
-constantPoolHandle to_cp, int to_i,
+const constantPoolHandle& to_cp, int to_i,
 TRAPS) {
 int tag = from_cp->tag_at(from_i).value();
 switch (tag) {
 case JVM_CONSTANT_Class:
 // Search constant pool search_cp for an entry that matches this
 // constant pool's entry at pattern_i. Returns the index of a
 // matching entry or zero (0) if there is no matching entry.
 int ConstantPool::find_matching_entry(int pattern_i,
-constantPoolHandle search_cp, TRAPS) {
+const constantPoolHandle& search_cp, TRAPS) {
 // index zero (0) is not used
 for (int i = 1; i < search_cp->length(); i++) {
 bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
 if (found) {
 } // 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) {
+bool ConstantPool::compare_operand_to(int idx1, const 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) {
 // 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) {
+const 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;
 }
 for (int i = 0; i< cp->length();  i++) {
 if (cp->tag_at(i).is_unresolved_klass()) {
 // This will force loading of the class
 Klass* klass = cp->klass_at(i, CHECK);
-if (klass->oop_is_instance()) {
+if (klass->is_instance_klass()) {
 // Force initialization of class
 InstanceKlass::cast(klass)->initialize(CHECK);
 }
 }
 }

changeset 33625	18e7896ca9fe
parent 33232	75e0112d3eb5
parent 33611	9abd65805e19
child 34229	892795cc82fe