truffle: src/share/vm/oops/cpCache.cpp annotate

annotate src/share/vm/oops/cpCache.cpp @ 17716:cdb71841f4bc

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	41cb10cbfb3c
children	3205e78d8193

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	2 * Copyright (c) 1998, 2013, 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
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	26 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	27 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	28 #include "interpreter/rewriter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	29 #include "memory/universe.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	30 #include "oops/cpCache.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	31 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	32 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	33 #include "prims/jvmtiRedefineClassesTrace.hpp"
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	34 #include "prims/methodHandles.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1903 diff changeset	35 #include "runtime/handles.inline.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6985 diff changeset	36 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6985 diff changeset	37 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	38 # include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6985 diff changeset	39 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	40
a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42 // Implememtation of ConstantPoolCacheEntry
a61af66fc99e Initial load duke parents: diff changeset	43
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	44 void ConstantPoolCacheEntry::initialize_entry(int index) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	45 assert(0 < index && index < 0x10000, "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	46 _indices = index;
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	47 _f1 = NULL;
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	48 _f2 = _flags = 0;
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	49 assert(constant_pool_index() == index, "");
0 a61af66fc99e Initial load duke parents: diff changeset	50 }
a61af66fc99e Initial load duke parents: diff changeset	51
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	52 int ConstantPoolCacheEntry::make_flags(TosState state,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	53 int option_bits,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	54 int field_index_or_method_params) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	55 assert(state < number_of_states, "Invalid state in make_flags");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	56 int f = ((int)state << tos_state_shift) \| option_bits \| field_index_or_method_params;
0 a61af66fc99e Initial load duke parents: diff changeset	57 // Preserve existing flag bit values
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	58 // The low bits are a field offset, or else the method parameter size.
0 a61af66fc99e Initial load duke parents: diff changeset	59 #ifdef ASSERT
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	60 TosState old_state = flag_state();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	61 assert(old_state == (TosState)0 \|\| old_state == state,
0 a61af66fc99e Initial load duke parents: diff changeset	62 "inconsistent cpCache flags state");
a61af66fc99e Initial load duke parents: diff changeset	63 #endif
a61af66fc99e Initial load duke parents: diff changeset	64 return (_flags \| f) ;
a61af66fc99e Initial load duke parents: diff changeset	65 }
a61af66fc99e Initial load duke parents: diff changeset	66
a61af66fc99e Initial load duke parents: diff changeset	67 void ConstantPoolCacheEntry::set_bytecode_1(Bytecodes::Code code) {
a61af66fc99e Initial load duke parents: diff changeset	68 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	69 // Read once.
a61af66fc99e Initial load duke parents: diff changeset	70 volatile Bytecodes::Code c = bytecode_1();
a61af66fc99e Initial load duke parents: diff changeset	71 assert(c == 0 \|\| c == code \|\| code == 0, "update must be consistent");
a61af66fc99e Initial load duke parents: diff changeset	72 #endif
a61af66fc99e Initial load duke parents: diff changeset	73 // Need to flush pending stores here before bytecode is written.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	74 OrderAccess::release_store_ptr(&_indices, _indices \| ((u_char)code << bytecode_1_shift));
0 a61af66fc99e Initial load duke parents: diff changeset	75 }
a61af66fc99e Initial load duke parents: diff changeset	76
a61af66fc99e Initial load duke parents: diff changeset	77 void ConstantPoolCacheEntry::set_bytecode_2(Bytecodes::Code code) {
a61af66fc99e Initial load duke parents: diff changeset	78 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	79 // Read once.
a61af66fc99e Initial load duke parents: diff changeset	80 volatile Bytecodes::Code c = bytecode_2();
a61af66fc99e Initial load duke parents: diff changeset	81 assert(c == 0 \|\| c == code \|\| code == 0, "update must be consistent");
a61af66fc99e Initial load duke parents: diff changeset	82 #endif
a61af66fc99e Initial load duke parents: diff changeset	83 // Need to flush pending stores here before bytecode is written.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	84 OrderAccess::release_store_ptr(&_indices, _indices \| ((u_char)code << bytecode_2_shift));
0 a61af66fc99e Initial load duke parents: diff changeset	85 }
a61af66fc99e Initial load duke parents: diff changeset	86
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	87 // Sets f1, ordering with previous writes.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	88 void ConstantPoolCacheEntry::release_set_f1(Metadata* f1) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	89 assert(f1 != NULL, "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	90 OrderAccess::release_store_ptr((HeapWord*) &_f1, f1);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	91 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	92
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	93 // Sets flags, but only if the value was previously zero.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	94 bool ConstantPoolCacheEntry::init_flags_atomic(intptr_t flags) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	95 intptr_t result = Atomic::cmpxchg_ptr(flags, &_flags, 0);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	96 return (result == 0);
2246 fbf3184da15d 7012339: JSR 292 crash in G1SATBCardTableModRefBS::write_ref_field_pre_work() twisti parents: 1972 diff changeset	97 }
1903 87d6a4d1ecbc 6990192: VM crashes in ciTypeFlow::get_block_for() twisti parents: 1662 diff changeset	98
0 a61af66fc99e Initial load duke parents: diff changeset	99 // Note that concurrent update of both bytecodes can leave one of them
a61af66fc99e Initial load duke parents: diff changeset	100 // reset to zero. This is harmless; the interpreter will simply re-resolve
a61af66fc99e Initial load duke parents: diff changeset	101 // the damaged entry. More seriously, the memory synchronization is needed
a61af66fc99e Initial load duke parents: diff changeset	102 // to flush other fields (f1, f2) completely to memory before the bytecodes
a61af66fc99e Initial load duke parents: diff changeset	103 // are updated, lest other processors see a non-zero bytecode but zero f1/f2.
a61af66fc99e Initial load duke parents: diff changeset	104 void ConstantPoolCacheEntry::set_field(Bytecodes::Code get_code,
a61af66fc99e Initial load duke parents: diff changeset	105 Bytecodes::Code put_code,
a61af66fc99e Initial load duke parents: diff changeset	106 KlassHandle field_holder,
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3785 diff changeset	107 int field_index,
0 a61af66fc99e Initial load duke parents: diff changeset	108 int field_offset,
a61af66fc99e Initial load duke parents: diff changeset	109 TosState field_type,
a61af66fc99e Initial load duke parents: diff changeset	110 bool is_final,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	111 bool is_volatile,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	112 Klass* root_klass) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	113 set_f1(field_holder());
0 a61af66fc99e Initial load duke parents: diff changeset	114 set_f2(field_offset);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	115 assert((field_index & field_index_mask) == field_index,
0 a61af66fc99e Initial load duke parents: diff changeset	116 "field index does not fit in low flag bits");
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	117 set_field_flags(field_type,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	118 ((is_volatile ? 1 : 0) << is_volatile_shift) \|
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	119 ((is_final ? 1 : 0) << is_final_shift),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	120 field_index);
0 a61af66fc99e Initial load duke parents: diff changeset	121 set_bytecode_1(get_code);
a61af66fc99e Initial load duke parents: diff changeset	122 set_bytecode_2(put_code);
a61af66fc99e Initial load duke parents: diff changeset	123 NOT_PRODUCT(verify(tty));
a61af66fc99e Initial load duke parents: diff changeset	124 }
a61af66fc99e Initial load duke parents: diff changeset	125
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	126 void ConstantPoolCacheEntry::set_parameter_size(int value) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	127 // This routine is called only in corner cases where the CPCE is not yet initialized.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	128 // See AbstractInterpreter::deopt_continue_after_entry.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	129 assert(_flags == 0 \|\| parameter_size() == 0 \|\| parameter_size() == value,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	130 err_msg("size must not change: parameter_size=%d, value=%d", parameter_size(), value));
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	131 // Setting the parameter size by itself is only safe if the
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	132 // current value of _flags is 0, otherwise another thread may have
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	133 // updated it and we don't want to overwrite that value. Don't
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	134 // bother trying to update it once it's nonzero but always make
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	135 // sure that the final parameter size agrees with what was passed.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	136 if (_flags == 0) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	137 Atomic::cmpxchg_ptr((value & parameter_size_mask), &_flags, 0);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	138 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	139 guarantee(parameter_size() == value,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	140 err_msg("size must not change: parameter_size=%d, value=%d", parameter_size(), value));
0 a61af66fc99e Initial load duke parents: diff changeset	141 }
a61af66fc99e Initial load duke parents: diff changeset	142
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	143 void ConstantPoolCacheEntry::set_direct_or_vtable_call(Bytecodes::Code invoke_code,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	144 methodHandle method,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	145 int vtable_index) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	146 bool is_vtable_call = (vtable_index >= 0); // FIXME: split this method on this boolean
0 a61af66fc99e Initial load duke parents: diff changeset	147 assert(method->interpreter_entry() != NULL, "should have been set at this point");
a61af66fc99e Initial load duke parents: diff changeset	148 assert(!method->is_obsolete(), "attempt to write obsolete method to cpCache");
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 int byte_no = -1;
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	151 bool change_to_virtual = false;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	152
0 a61af66fc99e Initial load duke parents: diff changeset	153 switch (invoke_code) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	154 case Bytecodes::_invokeinterface:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	155 // We get here from InterpreterRuntime::resolve_invoke when an invokeinterface
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	156 // instruction somehow links to a non-interface method (in Object).
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	157 // In that case, the method has no itable index and must be invoked as a virtual.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	158 // Set a flag to keep track of this corner case.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	159 change_to_virtual = true;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	160
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	161 // ...and fall through as if we were handling invokevirtual:
0 a61af66fc99e Initial load duke parents: diff changeset	162 case Bytecodes::_invokevirtual:
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	163 {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	164 if (!is_vtable_call) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	165 assert(method->can_be_statically_bound(), "");
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	166 // set_f2_as_vfinal_method checks if is_vfinal flag is true.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	167 set_method_flags(as_TosState(method->result_type()),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	168 ( 1 << is_vfinal_shift) \|
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	169 ((method->is_final_method() ? 1 : 0) << is_final_shift) \|
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	170 ((change_to_virtual ? 1 : 0) << is_forced_virtual_shift),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	171 method()->size_of_parameters());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	172 set_f2_as_vfinal_method(method());
0 a61af66fc99e Initial load duke parents: diff changeset	173 } else {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	174 assert(!method->can_be_statically_bound(), "");
0 a61af66fc99e Initial load duke parents: diff changeset	175 assert(vtable_index >= 0, "valid index");
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	176 assert(!method->is_final_method(), "sanity");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	177 set_method_flags(as_TosState(method->result_type()),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	178 ((change_to_virtual ? 1 : 0) << is_forced_virtual_shift),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	179 method()->size_of_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	180 set_f2(vtable_index);
a61af66fc99e Initial load duke parents: diff changeset	181 }
a61af66fc99e Initial load duke parents: diff changeset	182 byte_no = 2;
a61af66fc99e Initial load duke parents: diff changeset	183 break;
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	184 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	185
0 a61af66fc99e Initial load duke parents: diff changeset	186 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	187 case Bytecodes::_invokestatic:
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	188 assert(!is_vtable_call, "");
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	189 // Note: Read and preserve the value of the is_vfinal flag on any
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	190 // invokevirtual bytecode shared with this constant pool cache entry.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	191 // It is cheap and safe to consult is_vfinal() at all times.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	192 // Once is_vfinal is set, it must stay that way, lest we get a dangling oop.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	193 set_method_flags(as_TosState(method->result_type()),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	194 ((is_vfinal() ? 1 : 0) << is_vfinal_shift) \|
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	195 ((method->is_final_method() ? 1 : 0) << is_final_shift),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	196 method()->size_of_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	197 set_f1(method());
a61af66fc99e Initial load duke parents: diff changeset	198 byte_no = 1;
a61af66fc99e Initial load duke parents: diff changeset	199 break;
a61af66fc99e Initial load duke parents: diff changeset	200 default:
a61af66fc99e Initial load duke parents: diff changeset	201 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	202 break;
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 // Note: byte_no also appears in TemplateTable::resolve.
a61af66fc99e Initial load duke parents: diff changeset	206 if (byte_no == 1) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	207 assert(invoke_code != Bytecodes::_invokevirtual &&
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	208 invoke_code != Bytecodes::_invokeinterface, "");
0 a61af66fc99e Initial load duke parents: diff changeset	209 set_bytecode_1(invoke_code);
a61af66fc99e Initial load duke parents: diff changeset	210 } else if (byte_no == 2) {
a61af66fc99e Initial load duke parents: diff changeset	211 if (change_to_virtual) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	212 assert(invoke_code == Bytecodes::_invokeinterface, "");
0 a61af66fc99e Initial load duke parents: diff changeset	213 // NOTE: THIS IS A HACK - BE VERY CAREFUL!!!
a61af66fc99e Initial load duke parents: diff changeset	214 //
a61af66fc99e Initial load duke parents: diff changeset	215 // Workaround for the case where we encounter an invokeinterface, but we
a61af66fc99e Initial load duke parents: diff changeset	216 // should really have an _invokevirtual since the resolved method is a
a61af66fc99e Initial load duke parents: diff changeset	217 // virtual method in java.lang.Object. This is a corner case in the spec
a61af66fc99e Initial load duke parents: diff changeset	218 // but is presumably legal. javac does not generate this code.
a61af66fc99e Initial load duke parents: diff changeset	219 //
a61af66fc99e Initial load duke parents: diff changeset	220 // We set bytecode_1() to _invokeinterface, because that is the
a61af66fc99e Initial load duke parents: diff changeset	221 // bytecode # used by the interpreter to see if it is resolved.
a61af66fc99e Initial load duke parents: diff changeset	222 // We set bytecode_2() to _invokevirtual.
a61af66fc99e Initial load duke parents: diff changeset	223 // See also interpreterRuntime.cpp. (8/25/2000)
a61af66fc99e Initial load duke parents: diff changeset	224 // Only set resolved for the invokeinterface case if method is public.
a61af66fc99e Initial load duke parents: diff changeset	225 // Otherwise, the method needs to be reresolved with caller for each
a61af66fc99e Initial load duke parents: diff changeset	226 // interface call.
a61af66fc99e Initial load duke parents: diff changeset	227 if (method->is_public()) set_bytecode_1(invoke_code);
a61af66fc99e Initial load duke parents: diff changeset	228 } else {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	229 assert(invoke_code == Bytecodes::_invokevirtual, "");
0 a61af66fc99e Initial load duke parents: diff changeset	230 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	231 // set up for invokevirtual, even if linking for invokeinterface also:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	232 set_bytecode_2(Bytecodes::_invokevirtual);
0 a61af66fc99e Initial load duke parents: diff changeset	233 } else {
a61af66fc99e Initial load duke parents: diff changeset	234 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	235 }
a61af66fc99e Initial load duke parents: diff changeset	236 NOT_PRODUCT(verify(tty));
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	239 void ConstantPoolCacheEntry::set_direct_call(Bytecodes::Code invoke_code, methodHandle method) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	240 int index = Method::nonvirtual_vtable_index;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	241 // index < 0; FIXME: inline and customize set_direct_or_vtable_call
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	242 set_direct_or_vtable_call(invoke_code, method, index);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	243 }
0 a61af66fc99e Initial load duke parents: diff changeset	244
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	245 void ConstantPoolCacheEntry::set_vtable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	246 // either the method is a miranda or its holder should accept the given index
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	247 assert(method->method_holder()->is_interface() \|\| method->method_holder()->verify_vtable_index(index), "");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	248 // index >= 0; FIXME: inline and customize set_direct_or_vtable_call
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	249 set_direct_or_vtable_call(invoke_code, method, index);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	250 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	251
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	252 void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	253 assert(method->method_holder()->verify_itable_index(index), "");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10376 diff changeset	254 assert(invoke_code == Bytecodes::_invokeinterface, "");
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6822 diff changeset	255 InstanceKlass* interf = method->method_holder();
18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6822 diff changeset	256 assert(interf->is_interface(), "must be an interface");
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	257 assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
0 a61af66fc99e Initial load duke parents: diff changeset	258 set_f1(interf);
a61af66fc99e Initial load duke parents: diff changeset	259 set_f2(index);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	260 set_method_flags(as_TosState(method->result_type()),
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	261 0, // no option bits
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	262 method()->size_of_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	263 set_bytecode_1(Bytecodes::_invokeinterface);
a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	267 void ConstantPoolCacheEntry::set_method_handle(constantPoolHandle cpool, const CallInfo &call_info) {
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	268 set_method_handle_common(cpool, Bytecodes::_invokehandle, call_info);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	269 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	270
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	271 void ConstantPoolCacheEntry::set_dynamic_call(constantPoolHandle cpool, const CallInfo &call_info) {
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	272 set_method_handle_common(cpool, Bytecodes::_invokedynamic, call_info);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	273 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	274
6737 4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	275 void ConstantPoolCacheEntry::set_method_handle_common(constantPoolHandle cpool,
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	276 Bytecodes::Code invoke_code,
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	277 const CallInfo &call_info) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	278 // NOTE: This CPCE can be the subject of data races.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	279 // There are three words to update: flags, refs[f2], f1 (in that order).
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	280 // Writers must store all other values before f1.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	281 // Readers must test f1 first for non-null before reading other fields.
6737 4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	282 // Competing writers must acquire exclusive access via a lock.
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	283 // A losing writer waits on the lock until the winner writes f1 and leaves
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	284 // the lock, so that when the losing writer returns, he can use the linked
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	285 // cache entry.
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	286
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12316 diff changeset	287 MonitorLockerEx ml(cpool->lock());
6737 4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	288 if (!is_f1_null()) {
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	289 return;
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	290 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	291
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	292 const methodHandle adapter = call_info.resolved_method();
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	293 const Handle appendix = call_info.resolved_appendix();
64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	294 const Handle method_type = call_info.resolved_method_type();
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	295 const bool has_appendix = appendix.not_null();
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	296 const bool has_method_type = method_type.not_null();
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	297
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	298 // Write the flags.
6737 4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	299 set_method_flags(as_TosState(adapter->result_type()),
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	300 ((has_appendix ? 1 : 0) << has_appendix_shift ) \|
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	301 ((has_method_type ? 1 : 0) << has_method_type_shift) \|
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	302 ( 1 << is_final_shift ),
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	303 adapter->size_of_parameters());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	304
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	305 if (TraceInvokeDynamic) {
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	306 tty->print_cr("set_method_handle bc=%d appendix="PTR_FORMAT"%s method_type="PTR_FORMAT"%s method="PTR_FORMAT" ",
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	307 invoke_code,
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12264 diff changeset	308 (void *)appendix(), (has_appendix ? "" : " (unused)"),
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12264 diff changeset	309 (void *)method_type(), (has_method_type ? "" : " (unused)"),
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	310 (intptr_t)adapter());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	311 adapter->print();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	312 if (has_appendix) appendix()->print();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	313 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	314
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	315 // Method handle invokes and invokedynamic sites use both cp cache words.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	316 // refs[f2], if not null, contains a value passed as a trailing argument to the adapter.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	317 // In the general case, this could be the call site's MethodType,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	318 // for use with java.lang.Invokers.checkExactType, or else a CallSite object.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	319 // f1 contains the adapter method which manages the actual call.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	320 // In the general case, this is a compiled LambdaForm.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	321 // (The Java code is free to optimize these calls by binding other
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	322 // sorts of methods and appendices to call sites.)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	323 // JVM-level linking is via f1, as if for invokespecial, and signatures are erased.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	324 // The appendix argument (if any) is added to the signature, and is counted in the parameter_size bits.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	325 // Even with the appendix, the method will never take more than 255 parameter slots.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	326 //
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	327 // This means that given a call site like (List)mh.invoke("foo"),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	328 // the f1 method has signature '(Ljl/Object;Ljl/invoke/MethodType;)Ljl/Object;',
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	329 // not '(Ljava/lang/String;)Ljava/util/List;'.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	330 // The fact that String and List are involved is encoded in the MethodType in refs[f2].
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	331 // This allows us to create fewer method oops, while keeping type safety.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	332 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	333
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	334 objArrayHandle resolved_references = cpool->resolved_references();
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	335 // Store appendix, if any.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	336 if (has_appendix) {
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	337 const int appendix_index = f2_as_index() + _indy_resolved_references_appendix_offset;
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	338 assert(appendix_index >= 0 && appendix_index < resolved_references->length(), "oob");
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	339 assert(resolved_references->obj_at(appendix_index) == NULL, "init just once");
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	340 resolved_references->obj_at_put(appendix_index, appendix());
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	341 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	342
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	343 // Store MethodType, if any.
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	344 if (has_method_type) {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	345 const int method_type_index = f2_as_index() + _indy_resolved_references_method_type_offset;
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	346 assert(method_type_index >= 0 && method_type_index < resolved_references->length(), "oob");
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	347 assert(resolved_references->obj_at(method_type_index) == NULL, "init just once");
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	348 resolved_references->obj_at_put(method_type_index, method_type());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	349 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	350
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	351 release_set_f1(adapter()); // This must be the last one to set (see NOTE above)!
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	352
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	353 // The interpreter assembly code does not check byte_2,
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	354 // but it is used by is_resolved, method_if_resolved, etc.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	355 set_bytecode_1(invoke_code);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	356 NOT_PRODUCT(verify(tty));
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	357 if (TraceInvokeDynamic) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	358 this->print(tty, 0);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	359 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	360 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	361
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	362 Method* ConstantPoolCacheEntry::method_if_resolved(constantPoolHandle cpool) {
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	363 // Decode the action of set_method and set_interface_call
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	364 Bytecodes::Code invoke_code = bytecode_1();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	365 if (invoke_code != (Bytecodes::Code)0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	366 Metadata* f1 = (Metadata*)_f1;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	367 if (f1 != NULL) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	368 switch (invoke_code) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	369 case Bytecodes::_invokeinterface:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	370 assert(f1->is_klass(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	371 return klassItable::method_for_itable_index((Klass*)f1, f2_as_index());
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	372 case Bytecodes::_invokestatic:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	373 case Bytecodes::_invokespecial:
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	374 assert(!has_appendix(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	375 case Bytecodes::_invokehandle:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	376 case Bytecodes::_invokedynamic:
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	377 assert(f1->is_method(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	378 return (Method*)f1;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	379 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	380 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	381 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	382 invoke_code = bytecode_2();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	383 if (invoke_code != (Bytecodes::Code)0) {
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	384 switch (invoke_code) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	385 case Bytecodes::_invokevirtual:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	386 if (is_vfinal()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	387 // invokevirtual
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	388 Method* m = f2_as_vfinal_method();
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	389 assert(m->is_method(), "");
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	390 return m;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	391 } else {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	392 int holder_index = cpool->uncached_klass_ref_index_at(constant_pool_index());
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	393 if (cpool->tag_at(holder_index).is_klass()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	394 Klass* klass = cpool->resolved_klass_at(holder_index);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	395 if (!klass->oop_is_instance())
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	396 klass = SystemDictionary::Object_klass();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	397 return InstanceKlass::cast(klass)->method_at_vtable(f2_as_index());
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	398 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	399 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	400 break;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	401 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	402 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	403 return NULL;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	404 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	405
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	406
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	407 oop ConstantPoolCacheEntry::appendix_if_resolved(constantPoolHandle cpool) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	408 if (is_f1_null() \|\| !has_appendix())
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	409 return NULL;
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	410 const int ref_index = f2_as_index() + _indy_resolved_references_appendix_offset;
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	411 objArrayOop resolved_references = cpool->resolved_references();
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	412 return resolved_references->obj_at(ref_index);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	413 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	414
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	415
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	416 oop ConstantPoolCacheEntry::method_type_if_resolved(constantPoolHandle cpool) {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	417 if (is_f1_null() \|\| !has_method_type())
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	418 return NULL;
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	419 const int ref_index = f2_as_index() + _indy_resolved_references_method_type_offset;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	420 objArrayOop resolved_references = cpool->resolved_references();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	421 return resolved_references->obj_at(ref_index);
0 a61af66fc99e Initial load duke parents: diff changeset	422 }
a61af66fc99e Initial load duke parents: diff changeset	423
a61af66fc99e Initial load duke parents: diff changeset	424
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	425 #if INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	426 // RedefineClasses() API support:
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	427 // If this ConstantPoolCacheEntry refers to old_method then update it
0 a61af66fc99e Initial load duke parents: diff changeset	428 // to refer to new_method.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	429 bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	430 Method* new_method, bool * trace_name_printed) {
0 a61af66fc99e Initial load duke parents: diff changeset	431
a61af66fc99e Initial load duke parents: diff changeset	432 if (is_vfinal()) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	433 // virtual and final so _f2 contains method ptr instead of vtable index
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	434 if (f2_as_vfinal_method() == old_method) {
0 a61af66fc99e Initial load duke parents: diff changeset	435 // match old_method so need an update
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	436 // NOTE: can't use set_f2_as_vfinal_method as it asserts on different values
0 a61af66fc99e Initial load duke parents: diff changeset	437 _f2 = (intptr_t)new_method;
a61af66fc99e Initial load duke parents: diff changeset	438 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	439 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	440 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	441 RC_TRACE_MESG(("adjust: name=%s",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6822 diff changeset	442 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	443 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	446 RC_TRACE(0x00400000, ("cpc vf-entry update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	447 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	448 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	449 }
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 return true;
a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453
a61af66fc99e Initial load duke parents: diff changeset	454 // f1() is not used with virtual entries so bail out
a61af66fc99e Initial load duke parents: diff changeset	455 return false;
a61af66fc99e Initial load duke parents: diff changeset	456 }
a61af66fc99e Initial load duke parents: diff changeset	457
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	458 if (_f1 == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	459 // NULL f1() means this is a virtual entry so bail out
a61af66fc99e Initial load duke parents: diff changeset	460 // We are assuming that the vtable index does not need change.
a61af66fc99e Initial load duke parents: diff changeset	461 return false;
a61af66fc99e Initial load duke parents: diff changeset	462 }
a61af66fc99e Initial load duke parents: diff changeset	463
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	464 if (_f1 == old_method) {
0 a61af66fc99e Initial load duke parents: diff changeset	465 _f1 = new_method;
a61af66fc99e Initial load duke parents: diff changeset	466 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	467 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	468 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	469 RC_TRACE_MESG(("adjust: name=%s",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6822 diff changeset	470 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	471 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	472 }
a61af66fc99e Initial load duke parents: diff changeset	473 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	474 RC_TRACE(0x00400000, ("cpc entry update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	475 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	476 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	477 }
a61af66fc99e Initial load duke parents: diff changeset	478
a61af66fc99e Initial load duke parents: diff changeset	479 return true;
a61af66fc99e Initial load duke parents: diff changeset	480 }
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 return false;
a61af66fc99e Initial load duke parents: diff changeset	483 }
a61af66fc99e Initial load duke parents: diff changeset	484
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	485 // a constant pool cache entry should never contain old or obsolete methods
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	486 bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	487 if (is_vfinal()) {
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	488 // virtual and final so _f2 contains method ptr instead of vtable index
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	489 Metadata* f2 = (Metadata*)_f2;
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	490 // Return false if _f2 refers to an old or an obsolete method.
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	491 // _f2 == NULL \|\| !_f2->is_method() are just as unexpected here.
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	492 return (f2 != NULL NOT_PRODUCT(&& f2->is_valid()) && f2->is_method() &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	493 !((Method)f2)->is_old() && !((Method)f2)->is_obsolete());
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	494 } else if (_f1 == NULL \|\|
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	495 (NOT_PRODUCT(_f1->is_valid() &&) !_f1->is_method())) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	496 // _f1 == NULL \|\| !_f1->is_method() are OK here
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	497 return true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	498 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	499 // return false if _f1 refers to an old or an obsolete method
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	500 return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	501 !((Method)_f1)->is_old() && !((Method)_f1)->is_obsolete());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	502 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	503
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	504 bool ConstantPoolCacheEntry::is_interesting_method_entry(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	505 if (!is_method_entry()) {
a61af66fc99e Initial load duke parents: diff changeset	506 // not a method entry so not interesting by default
a61af66fc99e Initial load duke parents: diff changeset	507 return false;
a61af66fc99e Initial load duke parents: diff changeset	508 }
a61af66fc99e Initial load duke parents: diff changeset	509
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	510 Method* m = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	511 if (is_vfinal()) {
a61af66fc99e Initial load duke parents: diff changeset	512 // virtual and final so _f2 contains method ptr instead of vtable index
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	513 m = f2_as_vfinal_method();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	514 } else if (is_f1_null()) {
0 a61af66fc99e Initial load duke parents: diff changeset	515 // NULL _f1 means this is a virtual entry so also not interesting
a61af66fc99e Initial load duke parents: diff changeset	516 return false;
a61af66fc99e Initial load duke parents: diff changeset	517 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	518 if (!(_f1->is_method())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	519 // _f1 can also contain a Klass* for an interface
0 a61af66fc99e Initial load duke parents: diff changeset	520 return false;
a61af66fc99e Initial load duke parents: diff changeset	521 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	522 m = f1_as_method();
0 a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 assert(m != NULL && m->is_method(), "sanity check");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	526 if (m == NULL \|\| !m->is_method() \|\| (k != NULL && m->method_holder() != k)) {
0 a61af66fc99e Initial load duke parents: diff changeset	527 // robustness for above sanity checks or method is not in
a61af66fc99e Initial load duke parents: diff changeset	528 // the interesting class
a61af66fc99e Initial load duke parents: diff changeset	529 return false;
a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 // the method is in the interesting class so the entry is interesting
a61af66fc99e Initial load duke parents: diff changeset	533 return true;
a61af66fc99e Initial load duke parents: diff changeset	534 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	535 #endif // INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	536
a61af66fc99e Initial load duke parents: diff changeset	537 void ConstantPoolCacheEntry::print(outputStream* st, int index) const {
a61af66fc99e Initial load duke parents: diff changeset	538 // print separator
5898 f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	539 if (index == 0) st->print_cr(" -------------");
0 a61af66fc99e Initial load duke parents: diff changeset	540 // print entry
5898 f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	541 st->print("%3d ("PTR_FORMAT") ", index, (intptr_t)this);
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	542 st->print_cr("[%02x\|%02x\|%5d]", bytecode_2(), bytecode_1(),
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	543 constant_pool_index());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	544 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f1);
5898 f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	545 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f2);
f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	546 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_flags);
f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	547 st->print_cr(" -------------");
0 a61af66fc99e Initial load duke parents: diff changeset	548 }
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550 void ConstantPoolCacheEntry::verify(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	551 // not implemented yet
a61af66fc99e Initial load duke parents: diff changeset	552 }
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 // Implementation of ConstantPoolCache
a61af66fc99e Initial load duke parents: diff changeset	555
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	556 ConstantPoolCache* ConstantPoolCache::allocate(ClassLoaderData* loader_data,
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	557 const intStack& index_map,
13056 41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	558 const intStack& invokedynamic_index_map,
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	559 const intStack& invokedynamic_map, TRAPS) {
13056 41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	560
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	561 const int length = index_map.length() + invokedynamic_index_map.length();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	562 int size = ConstantPoolCache::size(length);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	563
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10152 diff changeset	564 return new (loader_data, size, false, MetaspaceObj::ConstantPoolCacheType, THREAD)
13056 41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	565 ConstantPoolCache(length, index_map, invokedynamic_index_map, invokedynamic_map);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	566 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	567
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	568 void ConstantPoolCache::initialize(const intArray& inverse_index_map,
13056 41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	569 const intArray& invokedynamic_inverse_index_map,
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	570 const intArray& invokedynamic_references_map) {
13056 41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	571 for (int i = 0; i < inverse_index_map.length(); i++) {
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	572 ConstantPoolCacheEntry* e = entry_at(i);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	573 int original_index = inverse_index_map[i];
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	574 e->initialize_entry(original_index);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	575 assert(entry_at(i) == e, "sanity");
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	576 }
13056 41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	577
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	578 // Append invokedynamic entries at the end
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	579 int invokedynamic_offset = inverse_index_map.length();
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	580 for (int i = 0; i < invokedynamic_inverse_index_map.length(); i++) {
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	581 int offset = i + invokedynamic_offset;
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	582 ConstantPoolCacheEntry* e = entry_at(offset);
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	583 int original_index = invokedynamic_inverse_index_map[i];
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	584 e->initialize_entry(original_index);
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	585 assert(entry_at(offset) == e, "sanity");
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	586 }
41cb10cbfb3c 8025937: assert(existing_f1 == NULL \|\| existing_f1 == f1) failed: illegal field change coleenp parents: 12946 diff changeset	587
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	588 for (int ref = 0; ref < invokedynamic_references_map.length(); ref++) {
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	589 const int cpci = invokedynamic_references_map[ref];
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	590 if (cpci >= 0) {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	591 #ifdef ASSERT
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	592 // invokedynamic and invokehandle have more entries; check if they
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	593 // all point to the same constant pool cache entry.
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	594 for (int entry = 1; entry < ConstantPoolCacheEntry::_indy_resolved_references_entries; entry++) {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	595 const int cpci_next = invokedynamic_references_map[ref + entry];
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	596 assert(cpci == cpci_next, err_msg_res("%d == %d", cpci, cpci_next));
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	597 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	598 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	599 entry_at(cpci)->initialize_resolved_reference_index(ref);
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	600 ref += ConstantPoolCacheEntry::_indy_resolved_references_entries - 1; // skip extra entries
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	601 }
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	602 }
0 a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	605 #if INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	606 // RedefineClasses() API support:
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	607 // If any entry of this ConstantPoolCache points to any of
0 a61af66fc99e Initial load duke parents: diff changeset	608 // old_methods, replace it with the corresponding new_method.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	609 void ConstantPoolCache::adjust_method_entries(Method old_methods, Method new_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	610 int methods_length, bool * trace_name_printed) {
a61af66fc99e Initial load duke parents: diff changeset	611
a61af66fc99e Initial load duke parents: diff changeset	612 if (methods_length == 0) {
a61af66fc99e Initial load duke parents: diff changeset	613 // nothing to do if there are no methods
a61af66fc99e Initial load duke parents: diff changeset	614 return;
a61af66fc99e Initial load duke parents: diff changeset	615 }
a61af66fc99e Initial load duke parents: diff changeset	616
a61af66fc99e Initial load duke parents: diff changeset	617 // get shorthand for the interesting class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	618 Klass* old_holder = old_methods[0]->method_holder();
0 a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 for (int i = 0; i < length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	621 if (!entry_at(i)->is_interesting_method_entry(old_holder)) {
a61af66fc99e Initial load duke parents: diff changeset	622 // skip uninteresting methods
a61af66fc99e Initial load duke parents: diff changeset	623 continue;
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	626 // The ConstantPoolCache contains entries for several different
0 a61af66fc99e Initial load duke parents: diff changeset	627 // things, but we only care about methods. In fact, we only care
a61af66fc99e Initial load duke parents: diff changeset	628 // about methods in the same class as the one that contains the
a61af66fc99e Initial load duke parents: diff changeset	629 // old_methods. At this point, we have an interesting entry.
a61af66fc99e Initial load duke parents: diff changeset	630
a61af66fc99e Initial load duke parents: diff changeset	631 for (int j = 0; j < methods_length; j++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	632 Method* old_method = old_methods[j];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	633 Method* new_method = new_methods[j];
0 a61af66fc99e Initial load duke parents: diff changeset	634
a61af66fc99e Initial load duke parents: diff changeset	635 if (entry_at(i)->adjust_method_entry(old_method, new_method,
a61af66fc99e Initial load duke parents: diff changeset	636 trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	637 // current old_method matched this entry and we updated it so
a61af66fc99e Initial load duke parents: diff changeset	638 // break out and get to the next interesting entry if there one
a61af66fc99e Initial load duke parents: diff changeset	639 break;
a61af66fc99e Initial load duke parents: diff changeset	640 }
a61af66fc99e Initial load duke parents: diff changeset	641 }
a61af66fc99e Initial load duke parents: diff changeset	642 }
a61af66fc99e Initial load duke parents: diff changeset	643 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	644
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	645 // the constant pool cache should never contain old or obsolete methods
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	646 bool ConstantPoolCache::check_no_old_or_obsolete_entries() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	647 for (int i = 1; i < length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	648 if (entry_at(i)->is_interesting_method_entry(NULL) &&
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	649 !entry_at(i)->check_no_old_or_obsolete_entries()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	650 return false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	651 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	652 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	653 return true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	654 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	655
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	656 void ConstantPoolCache::dump_cache() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	657 for (int i = 1; i < length(); i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	658 if (entry_at(i)->is_interesting_method_entry(NULL)) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	659 entry_at(i)->print(tty, i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	660 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	661 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	662 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	663 #endif // INCLUDE_JVMTI
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	664
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	665
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	666 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	667
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	668 void ConstantPoolCache::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	669 assert(is_constantPoolCache(), "obj must be constant pool cache");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	670 st->print_cr(internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	671 // print constant pool cache entries
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	672 for (int i = 0; i < length(); i++) entry_at(i)->print(st, i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	673 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	674
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	675 void ConstantPoolCache::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	676 assert(is_constantPoolCache(), "obj must be constant pool cache");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	677 st->print("cache [%d]", length());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	678 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	679 st->print(" for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	680 constant_pool()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	681 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	682
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	683
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	684 // Verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	685
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	686 void ConstantPoolCache::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	687 guarantee(is_constantPoolCache(), "obj must be constant pool cache");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	688 // print constant pool cache entries
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	689 for (int i = 0; i < length(); i++) entry_at(i)->verify(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	690 }

Mercurial > hg > truffle

annotate src/share/vm/oops/cpCache.cpp @ 17716:cdb71841f4bc