Mercurial > hg > truffle
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 | 1 /* |
1579 | 2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
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 | 22 * |
23 */ | |
24 | |
25 # include "incls/_precompiled.incl" | |
26 # include "incls/_rewriter.cpp.incl" | |
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 | 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 | 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 | 41 case JVM_CONSTANT_Fieldref : // fall through |
42 case JVM_CONSTANT_Methodref : // fall through | |
1602 | 43 case JVM_CONSTANT_MethodHandle : // fall through |
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 | 48 } |
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 | 55 } |
56 | |
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 | 91 } |
92 | |
93 | |
94 | |
95 // The new finalization semantics says that registration of | |
96 // finalizable objects must be performed on successful return from the | |
97 // Object.<init> constructor. We could implement this trivially if | |
98 // <init> were never rewritten but since JVMTI allows this to occur, a | |
99 // more complicated solution is required. A special return bytecode | |
100 // is used only by Object.<init> to signal the finalization | |
101 // registration point. Additionally local 0 must be preserved so it's | |
102 // available to pass to the registration function. For simplicty we | |
103 // require that local 0 is never overwritten so it's available as an | |
104 // argument for registration. | |
105 | |
106 void Rewriter::rewrite_Object_init(methodHandle method, TRAPS) { | |
107 RawBytecodeStream bcs(method); | |
108 while (!bcs.is_last_bytecode()) { | |
109 Bytecodes::Code opcode = bcs.raw_next(); | |
110 switch (opcode) { | |
111 case Bytecodes::_return: *bcs.bcp() = Bytecodes::_return_register_finalizer; break; | |
112 | |
113 case Bytecodes::_istore: | |
114 case Bytecodes::_lstore: | |
115 case Bytecodes::_fstore: | |
116 case Bytecodes::_dstore: | |
117 case Bytecodes::_astore: | |
118 if (bcs.get_index() != 0) continue; | |
119 | |
120 // fall through | |
121 case Bytecodes::_istore_0: | |
122 case Bytecodes::_lstore_0: | |
123 case Bytecodes::_fstore_0: | |
124 case Bytecodes::_dstore_0: | |
125 case Bytecodes::_astore_0: | |
126 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), | |
127 "can't overwrite local 0 in Object.<init>"); | |
128 break; | |
129 } | |
130 } | |
131 } | |
132 | |
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 | 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 | 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 | 163 // Rewrite some ldc bytecodes to _fast_aldc |
164 void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide) { | |
165 assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), ""); | |
166 address p = bcp + offset; | |
167 int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p); | |
168 constantTag tag = _pool->tag_at(cp_index).value(); | |
169 if (tag.is_method_handle() || tag.is_method_type()) { | |
170 int cache_index = cp_entry_to_cp_cache(cp_index); | |
171 if (is_wide) { | |
172 (*bcp) = Bytecodes::_fast_aldc_w; | |
173 assert(cache_index == (u2)cache_index, ""); | |
174 Bytes::put_native_u2(p, cache_index); | |
175 } else { | |
176 (*bcp) = Bytecodes::_fast_aldc; | |
177 assert(cache_index == (u1)cache_index, ""); | |
178 (*p) = (u1)cache_index; | |
179 } | |
180 } | |
181 } | |
182 | |
183 | |
0 | 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 | 186 |
187 int nof_jsrs = 0; | |
188 bool has_monitor_bytecodes = false; | |
189 | |
190 { | |
191 // We cannot tolerate a GC in this block, because we've | |
192 // cached the bytecodes in 'code_base'. If the methodOop | |
193 // moves, the bytecodes will also move. | |
194 No_Safepoint_Verifier nsv; | |
195 Bytecodes::Code c; | |
196 | |
197 // Bytecodes and their length | |
198 const address code_base = method->code_base(); | |
199 const int code_length = method->code_size(); | |
200 | |
201 int bc_length; | |
202 for (int bci = 0; bci < code_length; bci += bc_length) { | |
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 | 205 c = (Bytecodes::Code)(*bcp); |
206 | |
207 // Since we have the code, see if we can get the length | |
208 // directly. Some more complicated bytecodes will report | |
209 // a length of zero, meaning we need to make another method | |
210 // call to calculate the length. | |
211 bc_length = Bytecodes::length_for(c); | |
212 if (bc_length == 0) { | |
213 bc_length = Bytecodes::length_at(bcp); | |
214 | |
215 // length_at will put us at the bytecode after the one modified | |
216 // by 'wide'. We don't currently examine any of the bytecodes | |
217 // modified by wide, but in case we do in the future... | |
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 | 220 c = (Bytecodes::Code)bcp[1]; |
221 } | |
222 } | |
223 | |
224 assert(bc_length != 0, "impossible bytecode length"); | |
225 | |
226 switch (c) { | |
227 case Bytecodes::_lookupswitch : { | |
228 #ifndef CC_INTERP | |
229 Bytecode_lookupswitch* bc = Bytecode_lookupswitch_at(bcp); | |
1565 | 230 (*bcp) = ( |
0 | 231 bc->number_of_pairs() < BinarySwitchThreshold |
232 ? Bytecodes::_fast_linearswitch | |
233 : Bytecodes::_fast_binaryswitch | |
234 ); | |
235 #endif | |
236 break; | |
237 } | |
238 case Bytecodes::_getstatic : // fall through | |
239 case Bytecodes::_putstatic : // fall through | |
240 case Bytecodes::_getfield : // fall through | |
241 case Bytecodes::_putfield : // fall through | |
242 case Bytecodes::_invokevirtual : // fall through | |
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 | 247 break; |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
248 case Bytecodes::_invokedynamic: |
1565 | 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 | 251 case Bytecodes::_ldc: |
252 maybe_rewrite_ldc(bcp, prefix_length+1, false); | |
253 break; | |
254 case Bytecodes::_ldc_w: | |
255 maybe_rewrite_ldc(bcp, prefix_length+1, true); | |
256 break; | |
0 | 257 case Bytecodes::_jsr : // fall through |
258 case Bytecodes::_jsr_w : nof_jsrs++; break; | |
259 case Bytecodes::_monitorenter : // fall through | |
260 case Bytecodes::_monitorexit : has_monitor_bytecodes = true; break; | |
261 } | |
262 } | |
263 } | |
264 | |
265 // Update access flags | |
266 if (has_monitor_bytecodes) { | |
267 method->set_has_monitor_bytecodes(); | |
268 } | |
269 | |
270 // The present of a jsr bytecode implies that the method might potentially | |
271 // have to be rewritten, so we run the oopMapGenerator on the method | |
272 if (nof_jsrs > 0) { | |
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 | 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 | 292 } |
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 | 298 |
299 return method; | |
300 } | |
301 | |
302 | |
303 void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) { | |
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 | 323 |
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 | 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 | 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 | 332 if (method->intrinsic_id() == vmIntrinsics::_Object_init) { |
333 // rewrite the return bytecodes of Object.<init> to register the | |
334 // object for finalization if needed. | |
335 methodHandle m(THREAD, method); | |
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 | 338 break; |
339 } | |
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 | 342 } |
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 | 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 | 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 | 366 |
367 #ifdef ASSERT | |
368 if (StressMethodComparator) { | |
369 static int nmc = 0; | |
370 for (int j = i; j >= 0 && j >= i-4; j--) { | |
371 if ((++nmc % 1000) == 0) tty->print_cr("Have run MethodComparator %d times...", nmc); | |
372 bool z = MethodComparator::methods_EMCP(m(), (methodOop)_methods->obj_at(j)); | |
373 if (j == i && !z) { | |
374 tty->print("MethodComparator FAIL: "); m->print(); m->print_codes(); | |
375 assert(z, "method must compare equal to itself"); | |
376 } | |
377 } | |
378 } | |
379 #endif //ASSERT | |
0 | 380 } |
381 } |