Mercurial > hg > truffle

annotate src/share/vm/interpreter/rewriter.cpp @ 6972:bd7a7ce2e264

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6830717: replay of compilations would help with debugging Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method. Reviewed-by: kvn, twisti, sspitsyn Contributed-by: yumin.qi@oracle.com
author minqi
date Mon, 12 Nov 2012 14:03:53 -0800
parents f6b0eb4e44cf
children e522a00b91aa cc6a617fffd2
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
2 * Copyright (c) 1998, 2012, 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
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
26 #include "interpreter/bytecodes.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
27 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
28 #include "interpreter/rewriter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
29 #include "memory/gcLocker.hpp"
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
30 #include "memory/metadataFactory.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
31 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
32 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
33 #include "oops/generateOopMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
34 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
35 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1660
diff changeset
36 #include "prims/methodComparator.hpp"
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
37 #include "prims/methodHandles.hpp"
0
a61af66fc99e Initial load
duke
parents:
diff changeset
38
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
39 // Computes a CPC map (new_index -> original_index) for constant pool entries
0
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // 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
41 // Also computes a CP map (original_index -> new_index).
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
42 // Marks entries in CP which require additional processing.
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
43 void Rewriter::compute_index_maps() {
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
44 const int length = _pool->length();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
45 init_maps(length);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
46 bool saw_mh_symbol = false;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
47 for (int i = 0; i < length; i++) {
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
48 int tag = _pool->tag_at(i).value();
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
49 switch (tag) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
50 case JVM_CONSTANT_InterfaceMethodref:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
51 case JVM_CONSTANT_Fieldref : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
52 case JVM_CONSTANT_Methodref : // fall through
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
53 add_cp_cache_entry(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
54 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
55 case JVM_CONSTANT_String:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
56 case JVM_CONSTANT_Object:
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
57 case JVM_CONSTANT_MethodHandle : // fall through
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
58 case JVM_CONSTANT_MethodType : // fall through
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
59 add_resolved_references_entry(i);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
60 break;
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
61 case JVM_CONSTANT_Utf8:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
62 if (_pool->symbol_at(i) == vmSymbols::java_lang_invoke_MethodHandle())
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
63 saw_mh_symbol = true;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
64 break;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
65 }
a61af66fc99e Initial load
duke
parents:
diff changeset
66 }
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
67
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
68 // Record limits of resolved reference map for constant pool cache indices
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
69 record_map_limits();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
70
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
71 guarantee((int)_cp_cache_map.length()-1 <= (int)((u2)-1),
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
72 "all cp cache indexes fit in a u2");
1660
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 1602
diff changeset
73
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
74 if (saw_mh_symbol)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
75 _method_handle_invokers.initialize(length, (int)0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
76 }
a61af66fc99e Initial load
duke
parents:
diff changeset
77
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
78 // Unrewrite the bytecodes if an error occurs.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
79 void Rewriter::restore_bytecodes() {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
80 int len = _methods->length();
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
81
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
82 for (int i = len-1; i >= 0; i--) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
83 Method* method = _methods->at(i);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
84 scan_method(method, true);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
85 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
86 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
87
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
88 // Creates a constant pool cache given a CPC map
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
89 void Rewriter::make_constant_pool_cache(TRAPS) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
90 const int length = _cp_cache_map.length();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
91 ClassLoaderData* loader_data = _pool->pool_holder()->class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
92 ConstantPoolCache* cache =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
93 ConstantPoolCache::allocate(loader_data, length, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
94
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
95 // initialize object cache in constant pool
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
96 _pool->initialize_resolved_references(loader_data, _resolved_references_map,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
97 _resolved_reference_limit,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
98 CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
99
2226
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 2142
diff changeset
100 No_Safepoint_Verifier nsv;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
101 cache->initialize(_cp_cache_map, _invokedynamic_references_map);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
102 _pool->set_cache(cache);
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
103 cache->set_constant_pool(_pool());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
104 }
a61af66fc99e Initial load
duke
parents:
diff changeset
105
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // The new finalization semantics says that registration of
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // finalizable objects must be performed on successful return from the
a61af66fc99e Initial load
duke
parents:
diff changeset
110 // Object.<init> constructor. We could implement this trivially if
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // <init> were never rewritten but since JVMTI allows this to occur, a
a61af66fc99e Initial load
duke
parents:
diff changeset
112 // more complicated solution is required. A special return bytecode
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // is used only by Object.<init> to signal the finalization
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // registration point. Additionally local 0 must be preserved so it's
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // available to pass to the registration function. For simplicty we
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // require that local 0 is never overwritten so it's available as an
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // argument for registration.
a61af66fc99e Initial load
duke
parents:
diff changeset
118
a61af66fc99e Initial load
duke
parents:
diff changeset
119 void Rewriter::rewrite_Object_init(methodHandle method, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
120 RawBytecodeStream bcs(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
121 while (!bcs.is_last_bytecode()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
122 Bytecodes::Code opcode = bcs.raw_next();
a61af66fc99e Initial load
duke
parents:
diff changeset
123 switch (opcode) {
a61af66fc99e Initial load
duke
parents:
diff changeset
124 case Bytecodes::_return: *bcs.bcp() = Bytecodes::_return_register_finalizer; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
125
a61af66fc99e Initial load
duke
parents:
diff changeset
126 case Bytecodes::_istore:
a61af66fc99e Initial load
duke
parents:
diff changeset
127 case Bytecodes::_lstore:
a61af66fc99e Initial load
duke
parents:
diff changeset
128 case Bytecodes::_fstore:
a61af66fc99e Initial load
duke
parents:
diff changeset
129 case Bytecodes::_dstore:
a61af66fc99e Initial load
duke
parents:
diff changeset
130 case Bytecodes::_astore:
a61af66fc99e Initial load
duke
parents:
diff changeset
131 if (bcs.get_index() != 0) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
132
a61af66fc99e Initial load
duke
parents:
diff changeset
133 // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
134 case Bytecodes::_istore_0:
a61af66fc99e Initial load
duke
parents:
diff changeset
135 case Bytecodes::_lstore_0:
a61af66fc99e Initial load
duke
parents:
diff changeset
136 case Bytecodes::_fstore_0:
a61af66fc99e Initial load
duke
parents:
diff changeset
137 case Bytecodes::_dstore_0:
a61af66fc99e Initial load
duke
parents:
diff changeset
138 case Bytecodes::_astore_0:
a61af66fc99e Initial load
duke
parents:
diff changeset
139 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
a61af66fc99e Initial load
duke
parents:
diff changeset
140 "can't overwrite local 0 in Object.<init>");
a61af66fc99e Initial load
duke
parents:
diff changeset
141 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
142 }
a61af66fc99e Initial load
duke
parents:
diff changeset
143 }
a61af66fc99e Initial load
duke
parents:
diff changeset
144 }
a61af66fc99e Initial load
duke
parents:
diff changeset
145
a61af66fc99e Initial load
duke
parents:
diff changeset
146
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
147 // Rewrite a classfile-order CP index into a native-order CPC index.
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
148 void Rewriter::rewrite_member_reference(address bcp, int offset, bool reverse) {
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
149 address p = bcp + offset;
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
150 if (!reverse) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
151 int cp_index = Bytes::get_Java_u2(p);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
152 int cache_index = cp_entry_to_cp_cache(cp_index);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
153 Bytes::put_native_u2(p, cache_index);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
154 if (!_method_handle_invokers.is_empty())
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
155 maybe_rewrite_invokehandle(p - 1, cp_index, cache_index, reverse);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
156 } else {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
157 int cache_index = Bytes::get_native_u2(p);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
158 int pool_index = cp_cache_entry_pool_index(cache_index);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
159 Bytes::put_Java_u2(p, pool_index);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
160 if (!_method_handle_invokers.is_empty())
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
161 maybe_rewrite_invokehandle(p - 1, pool_index, cache_index, reverse);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
162 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
163 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
164
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
165
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
166 // Adjust the invocation bytecode for a signature-polymorphic method (MethodHandle.invoke, etc.)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
167 void Rewriter::maybe_rewrite_invokehandle(address opc, int cp_index, int cache_index, bool reverse) {
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
168 if (!reverse) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
169 if ((*opc) == (u1)Bytecodes::_invokevirtual ||
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
170 // allow invokespecial as an alias, although it would be very odd:
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
171 (*opc) == (u1)Bytecodes::_invokespecial) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
172 assert(_pool->tag_at(cp_index).is_method(), "wrong index");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
173 // Determine whether this is a signature-polymorphic method.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
174 if (cp_index >= _method_handle_invokers.length()) return;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
175 int status = _method_handle_invokers[cp_index];
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
176 assert(status >= -1 && status <= 1, "oob tri-state");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
177 if (status == 0) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
178 if (_pool->klass_ref_at_noresolve(cp_index) == vmSymbols::java_lang_invoke_MethodHandle() &&
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
179 MethodHandles::is_signature_polymorphic_name(SystemDictionary::MethodHandle_klass(),
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
180 _pool->name_ref_at(cp_index))) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
181 // we may need a resolved_refs entry for the appendix
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6725
diff changeset
182 add_invokedynamic_resolved_references_entries(cp_index, cache_index);
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
183 status = +1;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
184 } else {
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
185 status = -1;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
186 }
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
187 _method_handle_invokers[cp_index] = status;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
188 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
189 // We use a special internal bytecode for such methods (if non-static).
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
190 // The basic reason for this is that such methods need an extra "appendix" argument
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
191 // to transmit the call site's intended call type.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
192 if (status > 0) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
193 (*opc) = (u1)Bytecodes::_invokehandle;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
194 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
195 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
196 } else {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
197 // Do not need to look at cp_index.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
198 if ((*opc) == (u1)Bytecodes::_invokehandle) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
199 (*opc) = (u1)Bytecodes::_invokevirtual;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
200 // Ignore corner case of original _invokespecial instruction.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
201 // This is safe because (a) the signature polymorphic method was final, and
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
202 // (b) the implementation of MethodHandle will not call invokespecial on it.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
203 }
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
204 }
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
205 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
206
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
207
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
208 void Rewriter::rewrite_invokedynamic(address bcp, int offset, bool reverse) {
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
209 address p = bcp + offset;
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
210 assert(p[-1] == Bytecodes::_invokedynamic, "not invokedynamic bytecode");
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
211 if (!reverse) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
212 int cp_index = Bytes::get_Java_u2(p);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
213 int cache_index = add_invokedynamic_cp_cache_entry(cp_index);
6822
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 6725
diff changeset
214 add_invokedynamic_resolved_references_entries(cp_index, cache_index);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
215 // Replace the trailing four bytes with a CPC index for the dynamic
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
216 // call site. Unlike other CPC entries, there is one per bytecode,
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
217 // not just one per distinct CP entry. In other words, the
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
218 // CPC-to-CP relation is many-to-one for invokedynamic entries.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
219 // This means we must use a larger index size than u2 to address
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
220 // all these entries. That is the main reason invokedynamic
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
221 // must have a five-byte instruction format. (Of course, other JVM
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
222 // implementations can use the bytes for other purposes.)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
223 Bytes::put_native_u4(p, ConstantPool::encode_invokedynamic_index(cache_index));
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
224 // Note: We use native_u4 format exclusively for 4-byte indexes.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
225 } else {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
226 // callsite index
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
227 int cache_index = ConstantPool::decode_invokedynamic_index(
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
228 Bytes::get_native_u4(p));
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
229 int cp_index = cp_cache_entry_pool_index(cache_index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
230 assert(_pool->tag_at(cp_index).is_invoke_dynamic(), "wrong index");
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
231 // zero out 4 bytes
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
232 Bytes::put_Java_u4(p, 0);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
233 Bytes::put_Java_u2(p, cp_index);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
234 }
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
235 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
236
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
237
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
238 // Rewrite some ldc bytecodes to _fast_aldc
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
239 void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide,
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
240 bool reverse) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
241 if (!reverse) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
242 assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "not ldc bytecode");
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
243 address p = bcp + offset;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
244 int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
245 constantTag tag = _pool->tag_at(cp_index).value();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
246 if (tag.is_method_handle() || tag.is_method_type() || tag.is_string() || tag.is_object()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
247 int ref_index = cp_entry_to_resolved_references(cp_index);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
248 if (is_wide) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
249 (*bcp) = Bytecodes::_fast_aldc_w;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
250 assert(ref_index == (u2)ref_index, "index overflow");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
251 Bytes::put_native_u2(p, ref_index);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
252 } else {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
253 (*bcp) = Bytecodes::_fast_aldc;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
254 assert(ref_index == (u1)ref_index, "index overflow");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
255 (*p) = (u1)ref_index;
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
256 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
257 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
258 } else {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
259 Bytecodes::Code rewritten_bc =
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
260 (is_wide ? Bytecodes::_fast_aldc_w : Bytecodes::_fast_aldc);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
261 if ((*bcp) == rewritten_bc) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
262 address p = bcp + offset;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
263 int ref_index = is_wide ? Bytes::get_native_u2(p) : (u1)(*p);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
264 int pool_index = resolved_references_entry_to_pool_index(ref_index);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
265 if (is_wide) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
266 (*bcp) = Bytecodes::_ldc_w;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
267 assert(pool_index == (u2)pool_index, "index overflow");
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
268 Bytes::put_Java_u2(p, pool_index);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
269 } else {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
270 (*bcp) = Bytecodes::_ldc;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
271 assert(pool_index == (u1)pool_index, "index overflow");
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
272 (*p) = (u1)pool_index;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
273 }
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
274 }
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
275 }
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
276 }
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
277
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
278
0
a61af66fc99e Initial load
duke
parents:
diff changeset
279 // Rewrites a method given the index_map information
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
280 void Rewriter::scan_method(Method* method, bool reverse) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
281
a61af66fc99e Initial load
duke
parents:
diff changeset
282 int nof_jsrs = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
283 bool has_monitor_bytecodes = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
284
a61af66fc99e Initial load
duke
parents:
diff changeset
285 {
a61af66fc99e Initial load
duke
parents:
diff changeset
286 // We cannot tolerate a GC in this block, because we've
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
287 // cached the bytecodes in 'code_base'. If the Method*
0
a61af66fc99e Initial load
duke
parents:
diff changeset
288 // moves, the bytecodes will also move.
a61af66fc99e Initial load
duke
parents:
diff changeset
289 No_Safepoint_Verifier nsv;
a61af66fc99e Initial load
duke
parents:
diff changeset
290 Bytecodes::Code c;
a61af66fc99e Initial load
duke
parents:
diff changeset
291
a61af66fc99e Initial load
duke
parents:
diff changeset
292 // Bytecodes and their length
a61af66fc99e Initial load
duke
parents:
diff changeset
293 const address code_base = method->code_base();
a61af66fc99e Initial load
duke
parents:
diff changeset
294 const int code_length = method->code_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
295
a61af66fc99e Initial load
duke
parents:
diff changeset
296 int bc_length;
a61af66fc99e Initial load
duke
parents:
diff changeset
297 for (int bci = 0; bci < code_length; bci += bc_length) {
a61af66fc99e Initial load
duke
parents:
diff changeset
298 address bcp = code_base + bci;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
299 int prefix_length = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
300 c = (Bytecodes::Code)(*bcp);
a61af66fc99e Initial load
duke
parents:
diff changeset
301
a61af66fc99e Initial load
duke
parents:
diff changeset
302 // Since we have the code, see if we can get the length
a61af66fc99e Initial load
duke
parents:
diff changeset
303 // directly. Some more complicated bytecodes will report
a61af66fc99e Initial load
duke
parents:
diff changeset
304 // a length of zero, meaning we need to make another method
a61af66fc99e Initial load
duke
parents:
diff changeset
305 // call to calculate the length.
a61af66fc99e Initial load
duke
parents:
diff changeset
306 bc_length = Bytecodes::length_for(c);
a61af66fc99e Initial load
duke
parents:
diff changeset
307 if (bc_length == 0) {
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2011
diff changeset
308 bc_length = Bytecodes::length_at(method, bcp);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
309
a61af66fc99e Initial load
duke
parents:
diff changeset
310 // length_at will put us at the bytecode after the one modified
a61af66fc99e Initial load
duke
parents:
diff changeset
311 // by 'wide'. We don't currently examine any of the bytecodes
a61af66fc99e Initial load
duke
parents:
diff changeset
312 // modified by wide, but in case we do in the future...
a61af66fc99e Initial load
duke
parents:
diff changeset
313 if (c == Bytecodes::_wide) {
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
314 prefix_length = 1;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
315 c = (Bytecodes::Code)bcp[1];
a61af66fc99e Initial load
duke
parents:
diff changeset
316 }
a61af66fc99e Initial load
duke
parents:
diff changeset
317 }
a61af66fc99e Initial load
duke
parents:
diff changeset
318
a61af66fc99e Initial load
duke
parents:
diff changeset
319 assert(bc_length != 0, "impossible bytecode length");
a61af66fc99e Initial load
duke
parents:
diff changeset
320
a61af66fc99e Initial load
duke
parents:
diff changeset
321 switch (c) {
a61af66fc99e Initial load
duke
parents:
diff changeset
322 case Bytecodes::_lookupswitch : {
a61af66fc99e Initial load
duke
parents:
diff changeset
323 #ifndef CC_INTERP
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2011
diff changeset
324 Bytecode_lookupswitch bc(method, bcp);
1565
ab102d5d923e 6939207: refactor constant pool index processing
jrose
parents: 1138
diff changeset
325 (*bcp) = (
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2011
diff changeset
326 bc.number_of_pairs() < BinarySwitchThreshold
0
a61af66fc99e Initial load
duke
parents:
diff changeset
327 ? Bytecodes::_fast_linearswitch
a61af66fc99e Initial load
duke
parents:
diff changeset
328 : Bytecodes::_fast_binaryswitch
a61af66fc99e Initial load
duke
parents:
diff changeset
329 );
a61af66fc99e Initial load
duke
parents:
diff changeset
330 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
331 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
332 }
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
333 case Bytecodes::_fast_linearswitch:
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
334 case Bytecodes::_fast_binaryswitch: {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
335 #ifndef CC_INTERP
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
336 (*bcp) = Bytecodes::_lookupswitch;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
337 #endif
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
338 break;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
339 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
340 case Bytecodes::_getstatic : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
341 case Bytecodes::_putstatic : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
342 case Bytecodes::_getfield : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
343 case Bytecodes::_putfield : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
344 case Bytecodes::_invokevirtual : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
345 case Bytecodes::_invokespecial : // fall through
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
346 case Bytecodes::_invokestatic :
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
347 case Bytecodes::_invokeinterface:
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
348 case Bytecodes::_invokehandle : // if reverse=true
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
349 rewrite_member_reference(bcp, prefix_length+1, reverse);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
350 break;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
351 case Bytecodes::_invokedynamic:
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
352 rewrite_invokedynamic(bcp, prefix_length+1, reverse);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
353 break;
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
354 case Bytecodes::_ldc:
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
355 case Bytecodes::_fast_aldc: // if reverse=true
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
356 maybe_rewrite_ldc(bcp, prefix_length+1, false, reverse);
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
357 break;
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
358 case Bytecodes::_ldc_w:
6266
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 3748
diff changeset
359 case Bytecodes::_fast_aldc_w: // if reverse=true
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
360 maybe_rewrite_ldc(bcp, prefix_length+1, true, reverse);
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1579
diff changeset
361 break;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
362 case Bytecodes::_jsr : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
363 case Bytecodes::_jsr_w : nof_jsrs++; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
364 case Bytecodes::_monitorenter : // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
365 case Bytecodes::_monitorexit : has_monitor_bytecodes = true; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
366 }
a61af66fc99e Initial load
duke
parents:
diff changeset
367 }
a61af66fc99e Initial load
duke
parents:
diff changeset
368 }
a61af66fc99e Initial load
duke
parents:
diff changeset
369
a61af66fc99e Initial load
duke
parents:
diff changeset
370 // Update access flags
a61af66fc99e Initial load
duke
parents:
diff changeset
371 if (has_monitor_bytecodes) {
a61af66fc99e Initial load
duke
parents:
diff changeset
372 method->set_has_monitor_bytecodes();
a61af66fc99e Initial load
duke
parents:
diff changeset
373 }
a61af66fc99e Initial load
duke
parents:
diff changeset
374
a61af66fc99e Initial load
duke
parents:
diff changeset
375 // The present of a jsr bytecode implies that the method might potentially
a61af66fc99e Initial load
duke
parents:
diff changeset
376 // have to be rewritten, so we run the oopMapGenerator on the method
a61af66fc99e Initial load
duke
parents:
diff changeset
377 if (nof_jsrs > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
378 method->set_has_jsrs();
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
379 // Second pass will revisit this method.
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
380 assert(method->has_jsrs(), "didn't we just set this?");
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
381 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
382 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
383
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
384 // After constant pool is created, revisit methods containing jsrs.
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
385 methodHandle Rewriter::rewrite_jsrs(methodHandle method, TRAPS) {
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
386 ResourceMark rm(THREAD);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
387 ResolveOopMapConflicts romc(method);
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
388 methodHandle original_method = method;
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
389 method = romc.do_potential_rewrite(CHECK_(methodHandle()));
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
390 // Update monitor matching info.
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
391 if (romc.monitor_safe()) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
392 method->set_guaranteed_monitor_matching();
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
393 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
394
a61af66fc99e Initial load
duke
parents:
diff changeset
395 return method;
a61af66fc99e Initial load
duke
parents:
diff changeset
396 }
a61af66fc99e Initial load
duke
parents:
diff changeset
397
a61af66fc99e Initial load
duke
parents:
diff changeset
398 void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
399 ResourceMark rm(THREAD);
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
400 Rewriter rw(klass, klass->constants(), klass->methods(), CHECK);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
401 // (That's all, folks.)
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
402 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
403
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
404
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
405 void Rewriter::rewrite(instanceKlassHandle klass, constantPoolHandle cpool, Array<Method*>* methods, TRAPS) {
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
406 ResourceMark rm(THREAD);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
407 Rewriter rw(klass, cpool, methods, CHECK);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
408 // (That's all, folks.)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
409 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
410
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
411
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
412 Rewriter::Rewriter(instanceKlassHandle klass, constantPoolHandle cpool, Array<Method*>* methods, TRAPS)
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
413 : _klass(klass),
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
414 _pool(cpool),
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1059
diff changeset
415 _methods(methods)
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
416 {
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
417 assert(_pool->cache() == NULL, "constant pool cache must not be set yet");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
418
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
419 // determine index maps for Method* rewriting
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
420 compute_index_maps();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
421
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
422 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
423 bool did_rewrite = false;
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
424 int i = _methods->length();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
425 while (i-- > 0) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
426 Method* method = _methods->at(i);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
427 if (method->intrinsic_id() == vmIntrinsics::_Object_init) {
a61af66fc99e Initial load
duke
parents:
diff changeset
428 // rewrite the return bytecodes of Object.<init> to register the
a61af66fc99e Initial load
duke
parents:
diff changeset
429 // object for finalization if needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
430 methodHandle m(THREAD, method);
a61af66fc99e Initial load
duke
parents:
diff changeset
431 rewrite_Object_init(m, CHECK);
856
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 726
diff changeset
432 did_rewrite = true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
433 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
434 }
a61af66fc99e Initial load
duke
parents:
diff changeset
435 }
856
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 726
diff changeset
436 assert(did_rewrite, "must find Object::<init> to rewrite it");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
437 }
a61af66fc99e Initial load
duke
parents:
diff changeset
438
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
439 // rewrite methods, in two passes
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
440 int len = _methods->length();
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
441
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
442 for (int i = len-1; i >= 0; i--) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
443 Method* method = _methods->at(i);
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
444 scan_method(method);
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
445 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
446
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
447 // allocate constant pool cache, now that we've seen all the bytecodes
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
448 make_constant_pool_cache(THREAD);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
449
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
450 // Restore bytecodes to their unrewritten state if there are exceptions
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
451 // rewriting bytecodes or allocating the cpCache
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
452 if (HAS_PENDING_EXCEPTION) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
453 restore_bytecodes();
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
454 return;
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
455 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
456 }
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
457
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
458 // Relocate jsr/rets in a method. This can't be done with the rewriter
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
459 // stage because it can throw other exceptions, leaving the bytecodes
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
460 // pointing at constant pool cache entries.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
461 // Link and check jvmti dependencies while we're iterating over the methods.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
462 // JSR292 code calls with a different set of methods, so two entry points.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
463 void Rewriter::relocate_and_link(instanceKlassHandle this_oop, TRAPS) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
464 relocate_and_link(this_oop, this_oop->methods(), THREAD);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
465 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
466
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
467 void Rewriter::relocate_and_link(instanceKlassHandle this_oop,
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
468 Array<Method*>* methods, TRAPS) {
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
469 int len = methods->length();
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
470 for (int i = len-1; i >= 0; i--) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
471 methodHandle m(THREAD, methods->at(i));
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
472
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
473 if (m->has_jsrs()) {
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
474 m = rewrite_jsrs(m, CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
475 // Method might have gotten rewritten.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
476 methods->at_put(i, m());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
477 }
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
478
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
479 // Set up method entry points for compiler and interpreter .
726
be93aad57795 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 579
diff changeset
480 m->link_method(m, CHECK);
1574
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
481
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
482 // This is for JVMTI and unrelated to relocator but the last thing we do
1574
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
483 #ifdef ASSERT
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
484 if (StressMethodComparator) {
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
485 static int nmc = 0;
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
486 for (int j = i; j >= 0 && j >= i-4; j--) {
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
487 if ((++nmc % 1000) == 0) tty->print_cr("Have run MethodComparator %d times...", nmc);
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2460
diff changeset
488 bool z = MethodComparator::methods_EMCP(m(),
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
489 methods->at(j));
1574
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
490 if (j == i && !z) {
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
491 tty->print("MethodComparator FAIL: "); m->print(); m->print_codes();
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
492 assert(z, "method must compare equal to itself");
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
493 }
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
494 }
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
495 }
1eb493f33423 6957080: MethodComparator needs stress testing
jrose
parents: 1565
diff changeset
496 #endif //ASSERT
0
a61af66fc99e Initial load
duke
parents:
diff changeset
497 }
a61af66fc99e Initial load
duke
parents:
diff changeset
498 }