Tue, 24 Jul 2012 10:51:00 -0700
7023639: JSR 292 method handle invocation needs a fast path for compiled code
6984705: JSR 292 method handle creation should not go through JNI
Summary: remove assembly code for JDK 7 chained method handles
Reviewed-by: jrose, twisti, kvn, mhaupt
Contributed-by: John Rose <john.r.rose@oracle.com>, Christian Thalinger <christian.thalinger@oracle.com>, Michael Haupt <michael.haupt@oracle.com>
1 /*
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "precompiled.hpp"
26 #include "ci/ciCPCache.hpp"
27 #include "ci/ciCallSite.hpp"
28 #include "ci/ciConstant.hpp"
29 #include "ci/ciField.hpp"
30 #include "ci/ciStreams.hpp"
31 #include "ci/ciUtilities.hpp"
33 // ciExceptionHandlerStream
34 //
35 // Walk over some selected set of a methods exception handlers.
37 // ------------------------------------------------------------------
38 // ciExceptionHandlerStream::count
39 //
40 // How many exception handlers are there in this stream?
41 //
42 // Implementation note: Compiler2 needs this functionality, so I had
43 int ciExceptionHandlerStream::count() {
44 int save_pos = _pos;
45 int save_end = _end;
47 int count = 0;
49 _pos = -1;
50 _end = _method->_handler_count;
53 next();
54 while (!is_done()) {
55 count++;
56 next();
57 }
59 _pos = save_pos;
60 _end = save_end;
62 return count;
63 }
65 int ciExceptionHandlerStream::count_remaining() {
66 int save_pos = _pos;
67 int save_end = _end;
69 int count = 0;
71 while (!is_done()) {
72 count++;
73 next();
74 }
76 _pos = save_pos;
77 _end = save_end;
79 return count;
80 }
82 // ciBytecodeStream
83 //
84 // The class is used to iterate over the bytecodes of a method.
85 // It hides the details of constant pool structure/access by
86 // providing accessors for constant pool items.
88 // ------------------------------------------------------------------
89 // ciBytecodeStream::next_wide_or_table
90 //
91 // Special handling for switch ops
92 Bytecodes::Code ciBytecodeStream::next_wide_or_table(Bytecodes::Code bc) {
93 switch (bc) { // Check for special bytecode handling
94 case Bytecodes::_wide:
95 // Special handling for the wide bytcode
96 // Get following bytecode; do not return wide
97 assert(Bytecodes::Code(_pc[0]) == Bytecodes::_wide, "");
98 bc = Bytecodes::java_code(_raw_bc = (Bytecodes::Code)_pc[1]);
99 assert(Bytecodes::wide_length_for(bc) > 2, "must make progress");
100 _pc += Bytecodes::wide_length_for(bc);
101 _was_wide = _pc; // Flag last wide bytecode found
102 assert(is_wide(), "accessor works right");
103 break;
105 case Bytecodes::_lookupswitch:
106 _pc++; // Skip wide bytecode
107 _pc += (_start-_pc)&3; // Word align
108 _table_base = (jint*)_pc; // Capture for later usage
109 // table_base[0] is default far_dest
110 // Table has 2 lead elements (default, length), then pairs of u4 values.
111 // So load table length, and compute address at end of table
112 _pc = (address)&_table_base[2+ 2*Bytes::get_Java_u4((address)&_table_base[1])];
113 break;
115 case Bytecodes::_tableswitch: {
116 _pc++; // Skip wide bytecode
117 _pc += (_start-_pc)&3; // Word align
118 _table_base = (jint*)_pc; // Capture for later usage
119 // table_base[0] is default far_dest
120 int lo = Bytes::get_Java_u4((address)&_table_base[1]);// Low bound
121 int hi = Bytes::get_Java_u4((address)&_table_base[2]);// High bound
122 int len = hi - lo + 1; // Dense table size
123 _pc = (address)&_table_base[3+len]; // Skip past table
124 break;
125 }
127 default:
128 fatal("unhandled bytecode");
129 }
130 return bc;
131 }
133 // ------------------------------------------------------------------
134 // ciBytecodeStream::reset_to_bci
135 void ciBytecodeStream::reset_to_bci( int bci ) {
136 _bc_start=_was_wide=0;
137 _pc = _start+bci;
138 }
140 // ------------------------------------------------------------------
141 // ciBytecodeStream::force_bci
142 void ciBytecodeStream::force_bci(int bci) {
143 if (bci < 0) {
144 reset_to_bci(0);
145 _bc_start = _start + bci;
146 _bc = EOBC();
147 } else {
148 reset_to_bci(bci);
149 next();
150 }
151 }
154 // ------------------------------------------------------------------
155 // Constant pool access
156 // ------------------------------------------------------------------
158 // ------------------------------------------------------------------
159 // ciBytecodeStream::get_klass_index
160 //
161 // If this bytecodes references a klass, return the index of the
162 // referenced klass.
163 int ciBytecodeStream::get_klass_index() const {
164 switch(cur_bc()) {
165 case Bytecodes::_ldc:
166 return get_index_u1();
167 case Bytecodes::_ldc_w:
168 case Bytecodes::_ldc2_w:
169 case Bytecodes::_checkcast:
170 case Bytecodes::_instanceof:
171 case Bytecodes::_anewarray:
172 case Bytecodes::_multianewarray:
173 case Bytecodes::_new:
174 case Bytecodes::_newarray:
175 return get_index_u2();
176 default:
177 ShouldNotReachHere();
178 return 0;
179 }
180 }
182 // ------------------------------------------------------------------
183 // ciBytecodeStream::get_klass
184 //
185 // If this bytecode is a new, newarray, multianewarray, instanceof,
186 // or checkcast, get the referenced klass.
187 ciKlass* ciBytecodeStream::get_klass(bool& will_link) {
188 VM_ENTRY_MARK;
189 constantPoolHandle cpool(_method->get_methodOop()->constants());
190 return CURRENT_ENV->get_klass_by_index(cpool, get_klass_index(), will_link, _holder);
191 }
193 // ------------------------------------------------------------------
194 // ciBytecodeStream::get_constant_raw_index
195 //
196 // If this bytecode is one of the ldc variants, get the index of the
197 // referenced constant.
198 int ciBytecodeStream::get_constant_raw_index() const {
199 // work-alike for Bytecode_loadconstant::raw_index()
200 switch (cur_bc()) {
201 case Bytecodes::_ldc:
202 return get_index_u1();
203 case Bytecodes::_ldc_w:
204 case Bytecodes::_ldc2_w:
205 return get_index_u2();
206 default:
207 ShouldNotReachHere();
208 return 0;
209 }
210 }
212 // ------------------------------------------------------------------
213 // ciBytecodeStream::get_constant_pool_index
214 // Decode any CP cache index into a regular pool index.
215 int ciBytecodeStream::get_constant_pool_index() const {
216 // work-alike for Bytecode_loadconstant::pool_index()
217 int index = get_constant_raw_index();
218 if (has_cache_index()) {
219 return get_cpcache()->get_pool_index(index);
220 }
221 return index;
222 }
224 // ------------------------------------------------------------------
225 // ciBytecodeStream::get_constant_cache_index
226 // Return the CP cache index, or -1 if there isn't any.
227 int ciBytecodeStream::get_constant_cache_index() const {
228 // work-alike for Bytecode_loadconstant::cache_index()
229 return has_cache_index() ? get_constant_raw_index() : -1;
230 }
232 // ------------------------------------------------------------------
233 // ciBytecodeStream::get_constant
234 //
235 // If this bytecode is one of the ldc variants, get the referenced
236 // constant.
237 ciConstant ciBytecodeStream::get_constant() {
238 int pool_index = get_constant_raw_index();
239 int cache_index = -1;
240 if (has_cache_index()) {
241 cache_index = pool_index;
242 pool_index = -1;
243 }
244 VM_ENTRY_MARK;
245 constantPoolHandle cpool(_method->get_methodOop()->constants());
246 return CURRENT_ENV->get_constant_by_index(cpool, pool_index, cache_index, _holder);
247 }
249 // ------------------------------------------------------------------
250 // ciBytecodeStream::get_constant_pool_tag
251 //
252 // If this bytecode is one of the ldc variants, get the referenced
253 // constant.
254 constantTag ciBytecodeStream::get_constant_pool_tag(int index) const {
255 VM_ENTRY_MARK;
256 return _method->get_methodOop()->constants()->tag_at(index);
257 }
259 // ------------------------------------------------------------------
260 // ciBytecodeStream::get_field_index
261 //
262 // If this is a field access bytecode, get the constant pool
263 // index of the referenced field.
264 int ciBytecodeStream::get_field_index() {
265 assert(cur_bc() == Bytecodes::_getfield ||
266 cur_bc() == Bytecodes::_putfield ||
267 cur_bc() == Bytecodes::_getstatic ||
268 cur_bc() == Bytecodes::_putstatic, "wrong bc");
269 return get_index_u2_cpcache();
270 }
273 // ------------------------------------------------------------------
274 // ciBytecodeStream::get_field
275 //
276 // If this bytecode is one of get_field, get_static, put_field,
277 // or put_static, get the referenced field.
278 ciField* ciBytecodeStream::get_field(bool& will_link) {
279 ciField* f = CURRENT_ENV->get_field_by_index(_holder, get_field_index());
280 will_link = f->will_link(_holder, _bc);
281 return f;
282 }
285 // ------------------------------------------------------------------
286 // ciBytecodeStream::get_declared_field_holder
287 //
288 // Get the declared holder of the currently referenced field.
289 //
290 // Usage note: the holder() of a ciField class returns the canonical
291 // holder of the field, rather than the holder declared in the
292 // bytecodes.
293 //
294 // There is no "will_link" result passed back. The user is responsible
295 // for checking linkability when retrieving the associated field.
296 ciInstanceKlass* ciBytecodeStream::get_declared_field_holder() {
297 VM_ENTRY_MARK;
298 constantPoolHandle cpool(_method->get_methodOop()->constants());
299 int holder_index = get_field_holder_index();
300 bool ignore;
301 return CURRENT_ENV->get_klass_by_index(cpool, holder_index, ignore, _holder)
302 ->as_instance_klass();
303 }
305 // ------------------------------------------------------------------
306 // ciBytecodeStream::get_field_holder_index
307 //
308 // Get the constant pool index of the declared holder of the field
309 // referenced by the current bytecode. Used for generating
310 // deoptimization information.
311 int ciBytecodeStream::get_field_holder_index() {
312 GUARDED_VM_ENTRY(
313 constantPoolOop cpool = _holder->get_instanceKlass()->constants();
314 return cpool->klass_ref_index_at(get_field_index());
315 )
316 }
318 // ------------------------------------------------------------------
319 // ciBytecodeStream::get_field_signature_index
320 //
321 // Get the constant pool index of the signature of the field
322 // referenced by the current bytecode. Used for generating
323 // deoptimization information.
324 int ciBytecodeStream::get_field_signature_index() {
325 VM_ENTRY_MARK;
326 constantPoolOop cpool = _holder->get_instanceKlass()->constants();
327 int nt_index = cpool->name_and_type_ref_index_at(get_field_index());
328 return cpool->signature_ref_index_at(nt_index);
329 }
331 // ------------------------------------------------------------------
332 // ciBytecodeStream::get_method_index
333 //
334 // If this is a method invocation bytecode, get the constant pool
335 // index of the invoked method.
336 int ciBytecodeStream::get_method_index() {
337 #ifdef ASSERT
338 switch (cur_bc()) {
339 case Bytecodes::_invokeinterface:
340 case Bytecodes::_invokevirtual:
341 case Bytecodes::_invokespecial:
342 case Bytecodes::_invokestatic:
343 case Bytecodes::_invokedynamic:
344 break;
345 default:
346 ShouldNotReachHere();
347 }
348 #endif
349 if (has_index_u4())
350 return get_index_u4(); // invokedynamic
351 return get_index_u2_cpcache();
352 }
354 // ------------------------------------------------------------------
355 // ciBytecodeStream::get_method
356 //
357 // If this is a method invocation bytecode, get the invoked method.
358 ciMethod* ciBytecodeStream::get_method(bool& will_link) {
359 VM_ENTRY_MARK;
360 constantPoolHandle cpool(_method->get_methodOop()->constants());
361 ciMethod* m = CURRENT_ENV->get_method_by_index(cpool, get_method_index(), cur_bc(), _holder);
362 will_link = m->is_loaded();
363 return m;
364 }
366 // ------------------------------------------------------------------
367 // ciBytecodeStream::has_appendix
368 //
369 // Returns true if there is an appendix argument stored in the
370 // constant pool cache at the current bci.
371 bool ciBytecodeStream::has_appendix() {
372 VM_ENTRY_MARK;
373 constantPoolHandle cpool(_method->get_methodOop()->constants());
374 return constantPoolOopDesc::has_appendix_at_if_loaded(cpool, get_method_index());
375 }
377 // ------------------------------------------------------------------
378 // ciBytecodeStream::get_appendix
379 //
380 // Return the appendix argument stored in the constant pool cache at
381 // the current bci.
382 ciObject* ciBytecodeStream::get_appendix() {
383 VM_ENTRY_MARK;
384 constantPoolHandle cpool(_method->get_methodOop()->constants());
385 oop appendix_oop = constantPoolOopDesc::appendix_at_if_loaded(cpool, get_method_index());
386 return CURRENT_ENV->get_object(appendix_oop);
387 }
389 // ------------------------------------------------------------------
390 // ciBytecodeStream::get_declared_method_holder
391 //
392 // Get the declared holder of the currently referenced method.
393 //
394 // Usage note: the holder() of a ciMethod class returns the canonical
395 // holder of the method, rather than the holder declared in the
396 // bytecodes.
397 //
398 // There is no "will_link" result passed back. The user is responsible
399 // for checking linkability when retrieving the associated method.
400 ciKlass* ciBytecodeStream::get_declared_method_holder() {
401 VM_ENTRY_MARK;
402 constantPoolHandle cpool(_method->get_methodOop()->constants());
403 bool ignore;
404 // report as MethodHandle for invokedynamic, which is syntactically classless
405 if (cur_bc() == Bytecodes::_invokedynamic)
406 return CURRENT_ENV->get_klass_by_name(_holder, ciSymbol::java_lang_invoke_MethodHandle(), false);
407 return CURRENT_ENV->get_klass_by_index(cpool, get_method_holder_index(), ignore, _holder);
408 }
410 // ------------------------------------------------------------------
411 // ciBytecodeStream::get_method_holder_index
412 //
413 // Get the constant pool index of the declared holder of the method
414 // referenced by the current bytecode. Used for generating
415 // deoptimization information.
416 int ciBytecodeStream::get_method_holder_index() {
417 constantPoolOop cpool = _method->get_methodOop()->constants();
418 return cpool->klass_ref_index_at(get_method_index());
419 }
421 // ------------------------------------------------------------------
422 // ciBytecodeStream::get_declared_method_signature
423 //
424 // Get the declared signature of the currently referenced method.
425 //
426 // This is always the same as the signature of the resolved method
427 // itself, except for _invokehandle and _invokedynamic calls.
428 //
429 ciSignature* ciBytecodeStream::get_declared_method_signature() {
430 int sig_index = get_method_signature_index();
431 VM_ENTRY_MARK;
432 ciEnv* env = CURRENT_ENV;
433 constantPoolHandle cpool(_method->get_methodOop()->constants());
434 Symbol* sig_sym = cpool->symbol_at(sig_index);
435 ciKlass* pool_holder = env->get_object(cpool->pool_holder())->as_klass();
436 return new (env->arena()) ciSignature(pool_holder, cpool, env->get_symbol(sig_sym));
437 }
439 // ------------------------------------------------------------------
440 // ciBytecodeStream::get_method_signature_index
441 //
442 // Get the constant pool index of the signature of the method
443 // referenced by the current bytecode. Used for generating
444 // deoptimization information.
445 int ciBytecodeStream::get_method_signature_index() {
446 VM_ENTRY_MARK;
447 constantPoolOop cpool = _holder->get_instanceKlass()->constants();
448 int method_index = get_method_index();
449 int name_and_type_index = cpool->name_and_type_ref_index_at(method_index);
450 return cpool->signature_ref_index_at(name_and_type_index);
451 }
453 // ------------------------------------------------------------------
454 // ciBytecodeStream::get_cpcache
455 ciCPCache* ciBytecodeStream::get_cpcache() const {
456 if (_cpcache == NULL) {
457 VM_ENTRY_MARK;
458 // Get the constant pool.
459 constantPoolOop cpool = _holder->get_instanceKlass()->constants();
460 constantPoolCacheOop cpcache = cpool->cache();
462 *(ciCPCache**)&_cpcache = CURRENT_ENV->get_object(cpcache)->as_cpcache();
463 }
464 return _cpcache;
465 }
467 // ------------------------------------------------------------------
468 // ciBytecodeStream::get_call_site
469 ciCallSite* ciBytecodeStream::get_call_site() {
470 VM_ENTRY_MARK;
471 // Get the constant pool.
472 constantPoolOop cpool = _holder->get_instanceKlass()->constants();
473 constantPoolCacheOop cpcache = cpool->cache();
475 // Get the CallSite from the constant pool cache.
476 int method_index = get_method_index();
477 ConstantPoolCacheEntry* cpcache_entry = cpcache->secondary_entry_at(method_index);
478 oop call_site_oop = cpcache_entry->f1_as_instance();
480 // Create a CallSite object and return it.
481 return CURRENT_ENV->get_object(call_site_oop)->as_call_site();
482 }