truffle: src/share/vm/interpreter/rewriter.cpp annotate

annotate src/share/vm/interpreter/rewriter.cpp @ 1721:413ad0331a0c

6977924: Changes for 6975078 produce build error with certain gcc versions Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error. Reviewed-by: jcoomes, ysr, phh

author	johnc
date	Wed, 18 Aug 2010 10:59:06 -0700
parents	083fde3b838e
children	2d26b0046e0d f95d63e2154a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1579 e9ff18c4ace7 Merge jrose parents: 1552 1574 diff changeset	2 * Copyright (c) 1998, 2010, 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: 1138 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1138 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: 1138 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
a61af66fc99e Initial load duke parents: diff changeset	25 # include "incls/_precompiled.incl"
a61af66fc99e Initial load duke parents: diff changeset	26 # include "incls/_rewriter.cpp.incl"
a61af66fc99e Initial load duke parents: diff changeset	27
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	28 // Computes a CPC map (new_index -> original_index) for constant pool entries
0 a61af66fc99e Initial load duke parents: diff changeset	29 // that are referred to by the interpreter at runtime via the constant pool cache.
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	30 // Also computes a CP map (original_index -> new_index).
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	31 // Marks entries in CP which require additional processing.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	32 void Rewriter::compute_index_maps() {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	33 const int length = _pool->length();
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	34 init_cp_map(length);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	35 jint tag_mask = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	36 for (int i = 0; i < length; i++) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	37 int tag = _pool->tag_at(i).value();
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	38 tag_mask \|= (1 << tag);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	39 switch (tag) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	40 case JVM_CONSTANT_InterfaceMethodref:
0 a61af66fc99e Initial load duke parents: diff changeset	41 case JVM_CONSTANT_Fieldref : // fall through
a61af66fc99e Initial load duke parents: diff changeset	42 case JVM_CONSTANT_Methodref : // fall through
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	43 case JVM_CONSTANT_MethodHandle : // fall through
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	44 case JVM_CONSTANT_MethodType : // fall through
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	45 case JVM_CONSTANT_InvokeDynamic : // fall through
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	46 add_cp_cache_entry(i);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	47 break;
0 a61af66fc99e Initial load duke parents: diff changeset	48 }
a61af66fc99e Initial load duke parents: diff changeset	49 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	50
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	51 guarantee((int)_cp_cache_map.length()-1 <= (int)((u2)-1),
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	52 "all cp cache indexes fit in a u2");
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	53
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	54 _have_invoke_dynamic = ((tag_mask & (1 << JVM_CONSTANT_InvokeDynamic)) != 0);
0 a61af66fc99e Initial load duke parents: diff changeset	55 }
a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	58 // Creates a constant pool cache given a CPC map
542 9a25e0c45327 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark) jmasa parents: 0 diff changeset	59 // This creates the constant pool cache initially in a state
9a25e0c45327 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark) jmasa parents: 0 diff changeset	60 // that is unsafe for concurrent GC processing but sets it to
9a25e0c45327 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark) jmasa parents: 0 diff changeset	61 // a safe mode before the constant pool cache is returned.
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	62 void Rewriter::make_constant_pool_cache(TRAPS) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	63 const int length = _cp_cache_map.length();
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	64 constantPoolCacheOop cache =
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	65 oopFactory::new_constantPoolCache(length, methodOopDesc::IsUnsafeConc, CHECK);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	66 cache->initialize(_cp_cache_map);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	67
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	68 // Don't bother to the next pass if there is no JVM_CONSTANT_InvokeDynamic.
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	69 if (_have_invoke_dynamic) {
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	70 for (int i = 0; i < length; i++) {
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	71 int pool_index = cp_cache_entry_pool_index(i);
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	72 if (pool_index >= 0 &&
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	73 _pool->tag_at(pool_index).is_invoke_dynamic()) {
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	74 int bsm_index = _pool->invoke_dynamic_bootstrap_method_ref_index_at(pool_index);
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	75 if (bsm_index != 0) {
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	76 assert(_pool->tag_at(bsm_index).is_method_handle(), "must be a MH constant");
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	77 // There is a CP cache entry holding the BSM for these calls.
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	78 int bsm_cache_index = cp_entry_to_cp_cache(bsm_index);
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	79 cache->entry_at(i)->initialize_bootstrap_method_index_in_cache(bsm_cache_index);
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	80 } else {
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	81 // There is no CP cache entry holding the BSM for these calls.
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	82 // We will need to look for a class-global BSM, later.
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	83 guarantee(AllowTransitionalJSR292, "");
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	84 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	85 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	86 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	87 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	88
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	89 _pool->set_cache(cache);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	90 cache->set_constant_pool(_pool());
0 a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 // The new finalization semantics says that registration of
a61af66fc99e Initial load duke parents: diff changeset	96 // finalizable objects must be performed on successful return from the
a61af66fc99e Initial load duke parents: diff changeset	97 // Object.<init> constructor. We could implement this trivially if
a61af66fc99e Initial load duke parents: diff changeset	98 // <init> were never rewritten but since JVMTI allows this to occur, a
a61af66fc99e Initial load duke parents: diff changeset	99 // more complicated solution is required. A special return bytecode
a61af66fc99e Initial load duke parents: diff changeset	100 // is used only by Object.<init> to signal the finalization
a61af66fc99e Initial load duke parents: diff changeset	101 // registration point. Additionally local 0 must be preserved so it's
a61af66fc99e Initial load duke parents: diff changeset	102 // available to pass to the registration function. For simplicty we
a61af66fc99e Initial load duke parents: diff changeset	103 // require that local 0 is never overwritten so it's available as an
a61af66fc99e Initial load duke parents: diff changeset	104 // argument for registration.
a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 void Rewriter::rewrite_Object_init(methodHandle method, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	107 RawBytecodeStream bcs(method);
a61af66fc99e Initial load duke parents: diff changeset	108 while (!bcs.is_last_bytecode()) {
a61af66fc99e Initial load duke parents: diff changeset	109 Bytecodes::Code opcode = bcs.raw_next();
a61af66fc99e Initial load duke parents: diff changeset	110 switch (opcode) {
a61af66fc99e Initial load duke parents: diff changeset	111 case Bytecodes::_return: *bcs.bcp() = Bytecodes::_return_register_finalizer; break;
a61af66fc99e Initial load duke parents: diff changeset	112
a61af66fc99e Initial load duke parents: diff changeset	113 case Bytecodes::_istore:
a61af66fc99e Initial load duke parents: diff changeset	114 case Bytecodes::_lstore:
a61af66fc99e Initial load duke parents: diff changeset	115 case Bytecodes::_fstore:
a61af66fc99e Initial load duke parents: diff changeset	116 case Bytecodes::_dstore:
a61af66fc99e Initial load duke parents: diff changeset	117 case Bytecodes::_astore:
a61af66fc99e Initial load duke parents: diff changeset	118 if (bcs.get_index() != 0) continue;
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120 // fall through
a61af66fc99e Initial load duke parents: diff changeset	121 case Bytecodes::_istore_0:
a61af66fc99e Initial load duke parents: diff changeset	122 case Bytecodes::_lstore_0:
a61af66fc99e Initial load duke parents: diff changeset	123 case Bytecodes::_fstore_0:
a61af66fc99e Initial load duke parents: diff changeset	124 case Bytecodes::_dstore_0:
a61af66fc99e Initial load duke parents: diff changeset	125 case Bytecodes::_astore_0:
a61af66fc99e Initial load duke parents: diff changeset	126 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
a61af66fc99e Initial load duke parents: diff changeset	127 "can't overwrite local 0 in Object.<init>");
a61af66fc99e Initial load duke parents: diff changeset	128 break;
a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130 }
a61af66fc99e Initial load duke parents: diff changeset	131 }
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	134 // Rewrite a classfile-order CP index into a native-order CPC index.
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	135 void Rewriter::rewrite_member_reference(address bcp, int offset) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	136 address p = bcp + offset;
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	137 int cp_index = Bytes::get_Java_u2(p);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	138 int cache_index = cp_entry_to_cp_cache(cp_index);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	139 Bytes::put_native_u2(p, cache_index);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	140 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	141
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	142
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	143 void Rewriter::rewrite_invokedynamic(address bcp, int offset) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	144 address p = bcp + offset;
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	145 assert(p[-1] == Bytecodes::_invokedynamic, "");
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	146 int cp_index = Bytes::get_Java_u2(p);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	147 int cpc = maybe_add_cp_cache_entry(cp_index); // add lazily
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 856 diff changeset	148 int cpc2 = add_secondary_cp_cache_entry(cpc);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	149
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	150 // Replace the trailing four bytes with a CPC index for the dynamic
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	151 // call site. Unlike other CPC entries, there is one per bytecode,
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	152 // not just one per distinct CP entry. In other words, the
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	153 // CPC-to-CP relation is many-to-one for invokedynamic entries.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	154 // This means we must use a larger index size than u2 to address
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	155 // all these entries. That is the main reason invokedynamic
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	156 // must have a five-byte instruction format. (Of course, other JVM
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	157 // implementations can use the bytes for other purposes.)
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 856 diff changeset	158 Bytes::put_native_u4(p, constantPoolCacheOopDesc::encode_secondary_index(cpc2));
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	159 // Note: We use native_u4 format exclusively for 4-byte indexes.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	160 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	161
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	162
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	163 // Rewrite some ldc bytecodes to _fast_aldc
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	164 void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	165 assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	166 address p = bcp + offset;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	167 int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	168 constantTag tag = _pool->tag_at(cp_index).value();
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	169 if (tag.is_method_handle() \|\| tag.is_method_type()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	170 int cache_index = cp_entry_to_cp_cache(cp_index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	171 if (is_wide) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	172 (*bcp) = Bytecodes::_fast_aldc_w;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	173 assert(cache_index == (u2)cache_index, "");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	174 Bytes::put_native_u2(p, cache_index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	175 } else {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	176 (*bcp) = Bytecodes::_fast_aldc;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	177 assert(cache_index == (u1)cache_index, "");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	178 (*p) = (u1)cache_index;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	179 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	180 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	181 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	182
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	183
0 a61af66fc99e Initial load duke parents: diff changeset	184 // Rewrites a method given the index_map information
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	185 void Rewriter::scan_method(methodOop method) {
0 a61af66fc99e Initial load duke parents: diff changeset	186
a61af66fc99e Initial load duke parents: diff changeset	187 int nof_jsrs = 0;
a61af66fc99e Initial load duke parents: diff changeset	188 bool has_monitor_bytecodes = false;
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 {
a61af66fc99e Initial load duke parents: diff changeset	191 // We cannot tolerate a GC in this block, because we've
a61af66fc99e Initial load duke parents: diff changeset	192 // cached the bytecodes in 'code_base'. If the methodOop
a61af66fc99e Initial load duke parents: diff changeset	193 // moves, the bytecodes will also move.
a61af66fc99e Initial load duke parents: diff changeset	194 No_Safepoint_Verifier nsv;
a61af66fc99e Initial load duke parents: diff changeset	195 Bytecodes::Code c;
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 // Bytecodes and their length
a61af66fc99e Initial load duke parents: diff changeset	198 const address code_base = method->code_base();
a61af66fc99e Initial load duke parents: diff changeset	199 const int code_length = method->code_size();
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 int bc_length;
a61af66fc99e Initial load duke parents: diff changeset	202 for (int bci = 0; bci < code_length; bci += bc_length) {
a61af66fc99e Initial load duke parents: diff changeset	203 address bcp = code_base + bci;
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	204 int prefix_length = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	205 c = (Bytecodes::Code)(*bcp);
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 // Since we have the code, see if we can get the length
a61af66fc99e Initial load duke parents: diff changeset	208 // directly. Some more complicated bytecodes will report
a61af66fc99e Initial load duke parents: diff changeset	209 // a length of zero, meaning we need to make another method
a61af66fc99e Initial load duke parents: diff changeset	210 // call to calculate the length.
a61af66fc99e Initial load duke parents: diff changeset	211 bc_length = Bytecodes::length_for(c);
a61af66fc99e Initial load duke parents: diff changeset	212 if (bc_length == 0) {
a61af66fc99e Initial load duke parents: diff changeset	213 bc_length = Bytecodes::length_at(bcp);
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 // length_at will put us at the bytecode after the one modified
a61af66fc99e Initial load duke parents: diff changeset	216 // by 'wide'. We don't currently examine any of the bytecodes
a61af66fc99e Initial load duke parents: diff changeset	217 // modified by wide, but in case we do in the future...
a61af66fc99e Initial load duke parents: diff changeset	218 if (c == Bytecodes::_wide) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	219 prefix_length = 1;
0 a61af66fc99e Initial load duke parents: diff changeset	220 c = (Bytecodes::Code)bcp[1];
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222 }
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 assert(bc_length != 0, "impossible bytecode length");
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 switch (c) {
a61af66fc99e Initial load duke parents: diff changeset	227 case Bytecodes::_lookupswitch : {
a61af66fc99e Initial load duke parents: diff changeset	228 #ifndef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	229 Bytecode_lookupswitch* bc = Bytecode_lookupswitch_at(bcp);
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	230 (*bcp) = (
0 a61af66fc99e Initial load duke parents: diff changeset	231 bc->number_of_pairs() < BinarySwitchThreshold
a61af66fc99e Initial load duke parents: diff changeset	232 ? Bytecodes::_fast_linearswitch
a61af66fc99e Initial load duke parents: diff changeset	233 : Bytecodes::_fast_binaryswitch
a61af66fc99e Initial load duke parents: diff changeset	234 );
a61af66fc99e Initial load duke parents: diff changeset	235 #endif
a61af66fc99e Initial load duke parents: diff changeset	236 break;
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238 case Bytecodes::_getstatic : // fall through
a61af66fc99e Initial load duke parents: diff changeset	239 case Bytecodes::_putstatic : // fall through
a61af66fc99e Initial load duke parents: diff changeset	240 case Bytecodes::_getfield : // fall through
a61af66fc99e Initial load duke parents: diff changeset	241 case Bytecodes::_putfield : // fall through
a61af66fc99e Initial load duke parents: diff changeset	242 case Bytecodes::_invokevirtual : // fall through
a61af66fc99e Initial load duke parents: diff changeset	243 case Bytecodes::_invokespecial : // fall through
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	244 case Bytecodes::_invokestatic :
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	245 case Bytecodes::_invokeinterface:
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	246 rewrite_member_reference(bcp, prefix_length+1);
0 a61af66fc99e Initial load duke parents: diff changeset	247 break;
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	248 case Bytecodes::_invokedynamic:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	249 rewrite_invokedynamic(bcp, prefix_length+1);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	250 break;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	251 case Bytecodes::_ldc:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	252 maybe_rewrite_ldc(bcp, prefix_length+1, false);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	253 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	254 case Bytecodes::_ldc_w:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	255 maybe_rewrite_ldc(bcp, prefix_length+1, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	256 break;
0 a61af66fc99e Initial load duke parents: diff changeset	257 case Bytecodes::_jsr : // fall through
a61af66fc99e Initial load duke parents: diff changeset	258 case Bytecodes::_jsr_w : nof_jsrs++; break;
a61af66fc99e Initial load duke parents: diff changeset	259 case Bytecodes::_monitorenter : // fall through
a61af66fc99e Initial load duke parents: diff changeset	260 case Bytecodes::_monitorexit : has_monitor_bytecodes = true; break;
a61af66fc99e Initial load duke parents: diff changeset	261 }
a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263 }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 // Update access flags
a61af66fc99e Initial load duke parents: diff changeset	266 if (has_monitor_bytecodes) {
a61af66fc99e Initial load duke parents: diff changeset	267 method->set_has_monitor_bytecodes();
a61af66fc99e Initial load duke parents: diff changeset	268 }
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 // The present of a jsr bytecode implies that the method might potentially
a61af66fc99e Initial load duke parents: diff changeset	271 // have to be rewritten, so we run the oopMapGenerator on the method
a61af66fc99e Initial load duke parents: diff changeset	272 if (nof_jsrs > 0) {
a61af66fc99e Initial load duke parents: diff changeset	273 method->set_has_jsrs();
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	274 // Second pass will revisit this method.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	275 assert(method->has_jsrs(), "");
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	276 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	277 }
0 a61af66fc99e Initial load duke parents: diff changeset	278
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	279 // After constant pool is created, revisit methods containing jsrs.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	280 methodHandle Rewriter::rewrite_jsrs(methodHandle method, TRAPS) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	281 ResolveOopMapConflicts romc(method);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	282 methodHandle original_method = method;
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	283 method = romc.do_potential_rewrite(CHECK_(methodHandle()));
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	284 if (method() != original_method()) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	285 // Insert invalid bytecode into original methodOop and set
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	286 // interpreter entrypoint, so that a executing this method
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	287 // will manifest itself in an easy recognizable form.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	288 address bcp = original_method->bcp_from(0);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	289 *bcp = (u1)Bytecodes::_shouldnotreachhere;
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	290 int kind = Interpreter::method_kind(original_method);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	291 original_method->set_interpreter_kind(kind);
0 a61af66fc99e Initial load duke parents: diff changeset	292 }
a61af66fc99e Initial load duke parents: diff changeset	293
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	294 // Update monitor matching info.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	295 if (romc.monitor_safe()) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	296 method->set_guaranteed_monitor_matching();
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	297 }
0 a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 return method;
a61af66fc99e Initial load duke parents: diff changeset	300 }
a61af66fc99e Initial load duke parents: diff changeset	301
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	304 ResourceMark rm(THREAD);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	305 Rewriter rw(klass, klass->constants(), klass->methods(), CHECK);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	306 // (That's all, folks.)
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	307 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	308
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	309
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	310 void Rewriter::rewrite(instanceKlassHandle klass, constantPoolHandle cpool, objArrayHandle methods, TRAPS) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	311 ResourceMark rm(THREAD);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	312 Rewriter rw(klass, cpool, methods, CHECK);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	313 // (That's all, folks.)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	314 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	315
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	316
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	317 Rewriter::Rewriter(instanceKlassHandle klass, constantPoolHandle cpool, objArrayHandle methods, TRAPS)
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	318 : _klass(klass),
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	319 _pool(cpool),
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	320 _methods(methods)
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	321 {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	322 assert(_pool->cache() == NULL, "constant pool cache must not be set yet");
0 a61af66fc99e Initial load duke parents: diff changeset	323
a61af66fc99e Initial load duke parents: diff changeset	324 // determine index maps for methodOop rewriting
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	325 compute_index_maps();
0 a61af66fc99e Initial load duke parents: diff changeset	326
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	327 if (RegisterFinalizersAtInit && _klass->name() == vmSymbols::java_lang_Object()) {
856 75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics jrose parents: 726 diff changeset	328 bool did_rewrite = false;
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	329 int i = _methods->length();
0 a61af66fc99e Initial load duke parents: diff changeset	330 while (i-- > 0) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	331 methodOop method = (methodOop)_methods->obj_at(i);
0 a61af66fc99e Initial load duke parents: diff changeset	332 if (method->intrinsic_id() == vmIntrinsics::_Object_init) {
a61af66fc99e Initial load duke parents: diff changeset	333 // rewrite the return bytecodes of Object.<init> to register the
a61af66fc99e Initial load duke parents: diff changeset	334 // object for finalization if needed.
a61af66fc99e Initial load duke parents: diff changeset	335 methodHandle m(THREAD, method);
a61af66fc99e Initial load duke parents: diff changeset	336 rewrite_Object_init(m, CHECK);
856 75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics jrose parents: 726 diff changeset	337 did_rewrite = true;
0 a61af66fc99e Initial load duke parents: diff changeset	338 break;
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340 }
856 75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics jrose parents: 726 diff changeset	341 assert(did_rewrite, "must find Object::<init> to rewrite it");
0 a61af66fc99e Initial load duke parents: diff changeset	342 }
a61af66fc99e Initial load duke parents: diff changeset	343
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	344 // rewrite methods, in two passes
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	345 int i, len = _methods->length();
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	346
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	347 for (i = len; --i >= 0; ) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	348 methodOop method = (methodOop)_methods->obj_at(i);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	349 scan_method(method);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	350 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	351
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	352 // allocate constant pool cache, now that we've seen all the bytecodes
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	353 make_constant_pool_cache(CHECK);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	354
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	355 for (i = len; --i >= 0; ) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	356 methodHandle m(THREAD, (methodOop)_methods->obj_at(i));
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	357
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	358 if (m->has_jsrs()) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	359 m = rewrite_jsrs(m, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	360 // Method might have gotten rewritten.
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	361 _methods->obj_at_put(i, m());
0 a61af66fc99e Initial load duke parents: diff changeset	362 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	363
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	364 // Set up method entry points for compiler and interpreter.
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	365 m->link_method(m, CHECK);
1574 1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	366
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	367 #ifdef ASSERT
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	368 if (StressMethodComparator) {
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	369 static int nmc = 0;
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	370 for (int j = i; j >= 0 && j >= i-4; j--) {
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	371 if ((++nmc % 1000) == 0) tty->print_cr("Have run MethodComparator %d times...", nmc);
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	372 bool z = MethodComparator::methods_EMCP(m(), (methodOop)_methods->obj_at(j));
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	373 if (j == i && !z) {
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	374 tty->print("MethodComparator FAIL: "); m->print(); m->print_codes();
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	375 assert(z, "method must compare equal to itself");
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	376 }
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	377 }
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	378 }
1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1565 diff changeset	379 #endif //ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	380 }
a61af66fc99e Initial load duke parents: diff changeset	381 }

Mercurial > hg > truffle

annotate src/share/vm/interpreter/rewriter.cpp @ 1721:413ad0331a0c