graal-compiler: src/share/vm/oops/cpCache.cpp annotate

annotate src/share/vm/oops/cpCache.cpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	3efdfd6ddbf2
children	c115fac239eb

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
a61af66fc99e Initial load duke parents: diff changeset	143 void ConstantPoolCacheEntry::set_method(Bytecodes::Code invoke_code,
a61af66fc99e Initial load duke parents: diff changeset	144 methodHandle method,
a61af66fc99e Initial load duke parents: diff changeset	145 int vtable_index) {
a61af66fc99e Initial load duke parents: diff changeset	146 assert(method->interpreter_entry() != NULL, "should have been set at this point");
a61af66fc99e Initial load duke parents: diff changeset	147 assert(!method->is_obsolete(), "attempt to write obsolete method to cpCache");
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 int byte_no = -1;
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	150 bool change_to_virtual = false;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	151
0 a61af66fc99e Initial load duke parents: diff changeset	152 switch (invoke_code) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	153 case Bytecodes::_invokeinterface:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	154 // 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	155 // 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	156 // 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	157 // 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	158 change_to_virtual = true;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	159
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	160 // ...and fall through as if we were handling invokevirtual:
0 a61af66fc99e Initial load duke parents: diff changeset	161 case Bytecodes::_invokevirtual:
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	162 {
0 a61af66fc99e Initial load duke parents: diff changeset	163 if (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	164 // 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	165 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	166 ( 1 << is_vfinal_shift) \|
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	167 ((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	168 ((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	169 method()->size_of_parameters());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	170 set_f2_as_vfinal_method(method());
0 a61af66fc99e Initial load duke parents: diff changeset	171 } else {
a61af66fc99e Initial load duke parents: diff changeset	172 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	173 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	174 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	175 ((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	176 method()->size_of_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	177 set_f2(vtable_index);
a61af66fc99e Initial load duke parents: diff changeset	178 }
a61af66fc99e Initial load duke parents: diff changeset	179 byte_no = 2;
a61af66fc99e Initial load duke parents: diff changeset	180 break;
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	181 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	182
0 a61af66fc99e Initial load duke parents: diff changeset	183 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	184 case Bytecodes::_invokestatic:
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	185 // 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	186 // 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	187 // 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	188 // 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	189 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	190 ((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	191 ((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	192 method()->size_of_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	193 set_f1(method());
a61af66fc99e Initial load duke parents: diff changeset	194 byte_no = 1;
a61af66fc99e Initial load duke parents: diff changeset	195 break;
a61af66fc99e Initial load duke parents: diff changeset	196 default:
a61af66fc99e Initial load duke parents: diff changeset	197 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	198 break;
a61af66fc99e Initial load duke parents: diff changeset	199 }
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 // Note: byte_no also appears in TemplateTable::resolve.
a61af66fc99e Initial load duke parents: diff changeset	202 if (byte_no == 1) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	203 assert(invoke_code != Bytecodes::_invokevirtual &&
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	204 invoke_code != Bytecodes::_invokeinterface, "");
0 a61af66fc99e Initial load duke parents: diff changeset	205 set_bytecode_1(invoke_code);
a61af66fc99e Initial load duke parents: diff changeset	206 } else if (byte_no == 2) {
a61af66fc99e Initial load duke parents: diff changeset	207 if (change_to_virtual) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	208 assert(invoke_code == Bytecodes::_invokeinterface, "");
0 a61af66fc99e Initial load duke parents: diff changeset	209 // NOTE: THIS IS A HACK - BE VERY CAREFUL!!!
a61af66fc99e Initial load duke parents: diff changeset	210 //
a61af66fc99e Initial load duke parents: diff changeset	211 // Workaround for the case where we encounter an invokeinterface, but we
a61af66fc99e Initial load duke parents: diff changeset	212 // should really have an _invokevirtual since the resolved method is a
a61af66fc99e Initial load duke parents: diff changeset	213 // virtual method in java.lang.Object. This is a corner case in the spec
a61af66fc99e Initial load duke parents: diff changeset	214 // but is presumably legal. javac does not generate this code.
a61af66fc99e Initial load duke parents: diff changeset	215 //
a61af66fc99e Initial load duke parents: diff changeset	216 // We set bytecode_1() to _invokeinterface, because that is the
a61af66fc99e Initial load duke parents: diff changeset	217 // bytecode # used by the interpreter to see if it is resolved.
a61af66fc99e Initial load duke parents: diff changeset	218 // We set bytecode_2() to _invokevirtual.
a61af66fc99e Initial load duke parents: diff changeset	219 // See also interpreterRuntime.cpp. (8/25/2000)
a61af66fc99e Initial load duke parents: diff changeset	220 // Only set resolved for the invokeinterface case if method is public.
a61af66fc99e Initial load duke parents: diff changeset	221 // Otherwise, the method needs to be reresolved with caller for each
a61af66fc99e Initial load duke parents: diff changeset	222 // interface call.
a61af66fc99e Initial load duke parents: diff changeset	223 if (method->is_public()) set_bytecode_1(invoke_code);
a61af66fc99e Initial load duke parents: diff changeset	224 } else {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	225 assert(invoke_code == Bytecodes::_invokevirtual, "");
0 a61af66fc99e Initial load duke parents: diff changeset	226 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	227 // 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	228 set_bytecode_2(Bytecodes::_invokevirtual);
0 a61af66fc99e Initial load duke parents: diff changeset	229 } else {
a61af66fc99e Initial load duke parents: diff changeset	230 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232 NOT_PRODUCT(verify(tty));
a61af66fc99e Initial load duke parents: diff changeset	233 }
a61af66fc99e Initial load duke parents: diff changeset	234
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 void ConstantPoolCacheEntry::set_interface_call(methodHandle method, int index) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6822 diff changeset	237 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	238 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	239 assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
0 a61af66fc99e Initial load duke parents: diff changeset	240 set_f1(interf);
a61af66fc99e Initial load duke parents: diff changeset	241 set_f2(index);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	242 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	243 0, // no option bits
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	244 method()->size_of_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	245 set_bytecode_1(Bytecodes::_invokeinterface);
a61af66fc99e Initial load duke parents: diff changeset	246 }
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	249 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	250 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	251 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	252
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	253 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	254 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	255 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1552 diff changeset	256
6737 4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	257 void ConstantPoolCacheEntry::set_method_handle_common(constantPoolHandle cpool,
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	258 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	259 const CallInfo &call_info) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	260 // 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	261 // 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	262 // 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	263 // 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	264 // Competing writers must acquire exclusive access via a lock.
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	265 // 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	266 // 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	267 // cache entry.
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	268
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	269 MonitorLockerEx ml(cpool->lock());
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	270 if (!is_f1_null()) {
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	271 return;
4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	272 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	273
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	274 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	275 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	276 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	277 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	278 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	279
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	280 // Write the flags.
6737 4bfe8b33cf66 7196242: vm/mlvm/indy/stress/java/loopsAndThreads crashed twisti parents: 6725 diff changeset	281 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	282 ((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	283 ((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	284 ( 1 << is_final_shift ),
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	285 adapter->size_of_parameters());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	286
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	287 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	288 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	289 invoke_code,
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	290 (intptr_t)appendix(), (has_appendix ? "" : " (unused)"),
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	291 (intptr_t)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	292 (intptr_t)adapter());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	293 adapter->print();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	294 if (has_appendix) appendix()->print();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	295 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	296
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	297 // 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	298 // 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	299 // 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	300 // 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	301 // 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	302 // 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	303 // (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	304 // 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	305 // 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	306 // 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	307 // 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	308 //
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	309 // 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	310 // 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	311 // not '(Ljava/lang/String;)Ljava/util/List;'.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	312 // 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	313 // 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	314 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	315
6942 64672b22ef05 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common twisti parents: 6822 diff changeset	316 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	317 // Store appendix, if any.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	318 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	319 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	320 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	321 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	322 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	323 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	324
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	325 // 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	326 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	327 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	328 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	329 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	330 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	331 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	332
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	333 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	334
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 // 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	336 // 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	337 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	338 NOT_PRODUCT(verify(tty));
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	339 if (TraceInvokeDynamic) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	340 this->print(tty, 0);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	341 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	342 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	343
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	344 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	345 // 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	346 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	347 if (invoke_code != (Bytecodes::Code)0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	348 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	349 if (f1 != NULL) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	350 switch (invoke_code) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	351 case Bytecodes::_invokeinterface:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	352 assert(f1->is_klass(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	353 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	354 case Bytecodes::_invokestatic:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	355 case Bytecodes::_invokespecial:
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	356 assert(!has_appendix(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	357 case Bytecodes::_invokehandle:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	358 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	359 assert(f1->is_method(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	360 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	361 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	362 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	363 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	364 invoke_code = bytecode_2();
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) {
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	366 switch (invoke_code) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	367 case Bytecodes::_invokevirtual:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	368 if (is_vfinal()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	369 // invokevirtual
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	370 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	371 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	372 return m;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	373 } else {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	374 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	375 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	376 Klass* klass = cpool->resolved_klass_at(holder_index);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	377 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	378 klass = SystemDictionary::Object_klass();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	379 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	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 break;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	383 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	384 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	385 return NULL;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	386 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	387
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	388
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	389 oop ConstantPoolCacheEntry::appendix_if_resolved(constantPoolHandle cpool) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	390 if (is_f1_null() \|\| !has_appendix())
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	391 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	392 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	393 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	394 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	395 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	396
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	397
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	398 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	399 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	400 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	401 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	402 objArrayOop resolved_references = cpool->resolved_references();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	403 return resolved_references->obj_at(ref_index);
0 a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	407 #if INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	408 // RedefineClasses() API support:
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	409 // If this ConstantPoolCacheEntry refers to old_method then update it
0 a61af66fc99e Initial load duke parents: diff changeset	410 // to refer to new_method.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	411 bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	412 Method* new_method, bool * trace_name_printed) {
0 a61af66fc99e Initial load duke parents: diff changeset	413
a61af66fc99e Initial load duke parents: diff changeset	414 if (is_vfinal()) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	415 // 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	416 if (f2_as_vfinal_method() == old_method) {
0 a61af66fc99e Initial load duke parents: diff changeset	417 // 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	418 // NOTE: can't use set_f2_as_vfinal_method as it asserts on different values
0 a61af66fc99e Initial load duke parents: diff changeset	419 _f2 = (intptr_t)new_method;
a61af66fc99e Initial load duke parents: diff changeset	420 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	421 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	422 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	423 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	424 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	425 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	426 }
a61af66fc99e Initial load duke parents: diff changeset	427 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	428 RC_TRACE(0x00400000, ("cpc vf-entry update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	429 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	430 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	431 }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433 return true;
a61af66fc99e Initial load duke parents: diff changeset	434 }
a61af66fc99e Initial load duke parents: diff changeset	435
a61af66fc99e Initial load duke parents: diff changeset	436 // f1() is not used with virtual entries so bail out
a61af66fc99e Initial load duke parents: diff changeset	437 return false;
a61af66fc99e Initial load duke parents: diff changeset	438 }
a61af66fc99e Initial load duke parents: diff changeset	439
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	440 if (_f1 == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	441 // NULL f1() means this is a virtual entry so bail out
a61af66fc99e Initial load duke parents: diff changeset	442 // We are assuming that the vtable index does not need change.
a61af66fc99e Initial load duke parents: diff changeset	443 return false;
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	446 if (_f1 == old_method) {
0 a61af66fc99e Initial load duke parents: diff changeset	447 _f1 = new_method;
a61af66fc99e Initial load duke parents: diff changeset	448 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	449 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	450 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	451 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	452 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	453 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	454 }
a61af66fc99e Initial load duke parents: diff changeset	455 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	456 RC_TRACE(0x00400000, ("cpc entry update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	457 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	458 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	459 }
a61af66fc99e Initial load duke parents: diff changeset	460
a61af66fc99e Initial load duke parents: diff changeset	461 return true;
a61af66fc99e Initial load duke parents: diff changeset	462 }
a61af66fc99e Initial load duke parents: diff changeset	463
a61af66fc99e Initial load duke parents: diff changeset	464 return false;
a61af66fc99e Initial load duke parents: diff changeset	465 }
a61af66fc99e Initial load duke parents: diff changeset	466
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	467 // 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	468 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	469 if (is_vfinal()) {
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	470 // 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	471 Metadata* f2 = (Metadata*)_f2;
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	472 // 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	473 // _f2 == NULL \|\| !_f2->is_method() are just as unexpected here.
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	474 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	475 !((Method)f2)->is_old() && !((Method)f2)->is_obsolete());
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	476 } else if (_f1 == NULL \|\|
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	477 (NOT_PRODUCT(_f1->is_valid() &&) !_f1->is_method())) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	478 // _f1 == NULL \|\| !_f1->is_method() are OK here
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	479 return true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	480 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	481 // 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	482 return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	483 !((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	484 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	485
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	486 bool ConstantPoolCacheEntry::is_interesting_method_entry(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	487 if (!is_method_entry()) {
a61af66fc99e Initial load duke parents: diff changeset	488 // not a method entry so not interesting by default
a61af66fc99e Initial load duke parents: diff changeset	489 return false;
a61af66fc99e Initial load duke parents: diff changeset	490 }
a61af66fc99e Initial load duke parents: diff changeset	491
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	492 Method* m = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	493 if (is_vfinal()) {
a61af66fc99e Initial load duke parents: diff changeset	494 // 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	495 m = f2_as_vfinal_method();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	496 } else if (is_f1_null()) {
0 a61af66fc99e Initial load duke parents: diff changeset	497 // NULL _f1 means this is a virtual entry so also not interesting
a61af66fc99e Initial load duke parents: diff changeset	498 return false;
a61af66fc99e Initial load duke parents: diff changeset	499 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	500 if (!(_f1->is_method())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	501 // _f1 can also contain a Klass* for an interface
0 a61af66fc99e Initial load duke parents: diff changeset	502 return false;
a61af66fc99e Initial load duke parents: diff changeset	503 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5898 diff changeset	504 m = f1_as_method();
0 a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506
a61af66fc99e Initial load duke parents: diff changeset	507 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	508 if (m == NULL \|\| !m->is_method() \|\| (k != NULL && m->method_holder() != k)) {
0 a61af66fc99e Initial load duke parents: diff changeset	509 // robustness for above sanity checks or method is not in
a61af66fc99e Initial load duke parents: diff changeset	510 // the interesting class
a61af66fc99e Initial load duke parents: diff changeset	511 return false;
a61af66fc99e Initial load duke parents: diff changeset	512 }
a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514 // the method is in the interesting class so the entry is interesting
a61af66fc99e Initial load duke parents: diff changeset	515 return true;
a61af66fc99e Initial load duke parents: diff changeset	516 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	517 #endif // INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	518
a61af66fc99e Initial load duke parents: diff changeset	519 void ConstantPoolCacheEntry::print(outputStream* st, int index) const {
a61af66fc99e Initial load duke parents: diff changeset	520 // print separator
5898 f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	521 if (index == 0) st->print_cr(" -------------");
0 a61af66fc99e Initial load duke parents: diff changeset	522 // print entry
5898 f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	523 st->print("%3d ("PTR_FORMAT") ", index, (intptr_t)this);
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	524 st->print_cr("[%02x\|%02x\|%5d]", bytecode_2(), bytecode_1(),
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	525 constant_pool_index());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	526 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f1);
5898 f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	527 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f2);
f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	528 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_flags);
f096e1b74d85 7148126: ConstantPoolCacheEntry::print prints to wrong stream dholmes parents: 3938 diff changeset	529 st->print_cr(" -------------");
0 a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 void ConstantPoolCacheEntry::verify(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	533 // not implemented yet
a61af66fc99e Initial load duke parents: diff changeset	534 }
a61af66fc99e Initial load duke parents: diff changeset	535
a61af66fc99e Initial load duke parents: diff changeset	536 // Implementation of ConstantPoolCache
a61af66fc99e Initial load duke parents: diff changeset	537
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	538 ConstantPoolCache* ConstantPoolCache::allocate(ClassLoaderData* loader_data,
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	539 int length,
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	540 const intStack& index_map,
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	541 const intStack& invokedynamic_map, TRAPS) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	542 int size = ConstantPoolCache::size(length);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	543
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	544 return new (loader_data, size, false, THREAD) ConstantPoolCache(length, index_map, invokedynamic_map);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	545 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	546
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	547 void ConstantPoolCache::initialize(const intArray& inverse_index_map,
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8025 diff changeset	548 const intArray& invokedynamic_references_map) {
0 a61af66fc99e Initial load duke parents: diff changeset	549 assert(inverse_index_map.length() == length(), "inverse index map must have same length as cache");
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	550 for (int i = 0; i < length(); i++) {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	551 ConstantPoolCacheEntry* e = entry_at(i);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	552 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	553 e->initialize_entry(original_index);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	554 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	555 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	556 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	557 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	558 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	559 #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	560 // 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	561 // 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	562 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	563 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	564 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	565 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6737 diff changeset	566 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	567 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	568 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	569 }
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 844 diff changeset	570 }
0 a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	573 #if INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	574 // RedefineClasses() API support:
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	575 // If any entry of this ConstantPoolCache points to any of
0 a61af66fc99e Initial load duke parents: diff changeset	576 // 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	577 void ConstantPoolCache::adjust_method_entries(Method old_methods, Method new_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	578 int methods_length, bool * trace_name_printed) {
a61af66fc99e Initial load duke parents: diff changeset	579
a61af66fc99e Initial load duke parents: diff changeset	580 if (methods_length == 0) {
a61af66fc99e Initial load duke parents: diff changeset	581 // nothing to do if there are no methods
a61af66fc99e Initial load duke parents: diff changeset	582 return;
a61af66fc99e Initial load duke parents: diff changeset	583 }
a61af66fc99e Initial load duke parents: diff changeset	584
a61af66fc99e Initial load duke parents: diff changeset	585 // get shorthand for the interesting class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	586 Klass* old_holder = old_methods[0]->method_holder();
0 a61af66fc99e Initial load duke parents: diff changeset	587
a61af66fc99e Initial load duke parents: diff changeset	588 for (int i = 0; i < length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	589 if (!entry_at(i)->is_interesting_method_entry(old_holder)) {
a61af66fc99e Initial load duke parents: diff changeset	590 // skip uninteresting methods
a61af66fc99e Initial load duke parents: diff changeset	591 continue;
a61af66fc99e Initial load duke parents: diff changeset	592 }
a61af66fc99e Initial load duke parents: diff changeset	593
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	594 // The ConstantPoolCache contains entries for several different
0 a61af66fc99e Initial load duke parents: diff changeset	595 // things, but we only care about methods. In fact, we only care
a61af66fc99e Initial load duke parents: diff changeset	596 // about methods in the same class as the one that contains the
a61af66fc99e Initial load duke parents: diff changeset	597 // old_methods. At this point, we have an interesting entry.
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599 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	600 Method* old_method = old_methods[j];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	601 Method* new_method = new_methods[j];
0 a61af66fc99e Initial load duke parents: diff changeset	602
a61af66fc99e Initial load duke parents: diff changeset	603 if (entry_at(i)->adjust_method_entry(old_method, new_method,
a61af66fc99e Initial load duke parents: diff changeset	604 trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	605 // current old_method matched this entry and we updated it so
a61af66fc99e Initial load duke parents: diff changeset	606 // break out and get to the next interesting entry if there one
a61af66fc99e Initial load duke parents: diff changeset	607 break;
a61af66fc99e Initial load duke parents: diff changeset	608 }
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610 }
a61af66fc99e Initial load duke parents: diff changeset	611 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	612
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	613 // 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	614 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	615 for (int i = 1; i < length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	616 if (entry_at(i)->is_interesting_method_entry(NULL) &&
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	617 !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	618 return false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	619 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	620 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	621 return true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	622 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	623
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	624 void ConstantPoolCache::dump_cache() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	625 for (int i = 1; i < length(); i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	626 if (entry_at(i)->is_interesting_method_entry(NULL)) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	627 entry_at(i)->print(tty, i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	628 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	629 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	630 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6985 diff changeset	631 #endif // INCLUDE_JVMTI
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	632
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	633
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	634 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	635
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	636 void ConstantPoolCache::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	637 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	638 st->print_cr(internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	639 // print constant pool cache entries
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	640 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	641 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	642
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	643 void ConstantPoolCache::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	644 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	645 st->print("cache [%d]", length());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	646 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	647 st->print(" for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	648 constant_pool()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	649 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	650
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 // Verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	653
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	654 void ConstantPoolCache::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	655 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	656 // print constant pool cache entries
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	657 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	658 }

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/cpCache.cpp @ 10185:d50cc62e94ff