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) 1997, 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 #ifndef SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP
26 #define SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP
28 #include "oops/arrayOop.hpp"
29 #include "oops/cpCacheOop.hpp"
30 #include "oops/symbol.hpp"
31 #include "oops/typeArrayOop.hpp"
32 #include "utilities/constantTag.hpp"
33 #ifdef TARGET_ARCH_x86
34 # include "bytes_x86.hpp"
35 #endif
36 #ifdef TARGET_ARCH_sparc
37 # include "bytes_sparc.hpp"
38 #endif
39 #ifdef TARGET_ARCH_zero
40 # include "bytes_zero.hpp"
41 #endif
42 #ifdef TARGET_ARCH_arm
43 # include "bytes_arm.hpp"
44 #endif
45 #ifdef TARGET_ARCH_ppc
46 # include "bytes_ppc.hpp"
47 #endif
49 // A constantPool is an array containing class constants as described in the
50 // class file.
51 //
52 // Most of the constant pool entries are written during class parsing, which
53 // is safe. For klass and string types, the constant pool entry is
54 // modified when the entry is resolved. If a klass or string constant pool
55 // entry is read without a lock, only the resolved state guarantees that
56 // the entry in the constant pool is a klass or String object and
57 // not a Symbol*.
59 class SymbolHashMap;
61 class CPSlot VALUE_OBJ_CLASS_SPEC {
62 intptr_t _ptr;
63 public:
64 CPSlot(intptr_t ptr): _ptr(ptr) {}
65 CPSlot(void* ptr): _ptr((intptr_t)ptr) {}
66 CPSlot(oop ptr): _ptr((intptr_t)ptr) {}
67 CPSlot(Symbol* ptr): _ptr((intptr_t)ptr | 1) {}
69 intptr_t value() { return _ptr; }
70 bool is_oop() { return (_ptr & 1) == 0; }
71 bool is_metadata() { return (_ptr & 1) == 1; }
73 oop get_oop() {
74 assert(is_oop(), "bad call");
75 return oop(_ptr);
76 }
77 Symbol* get_symbol() {
78 assert(is_metadata(), "bad call");
79 return (Symbol*)(_ptr & ~1);
80 }
81 };
83 class constantPoolOopDesc : public oopDesc {
84 friend class VMStructs;
85 friend class BytecodeInterpreter; // Directly extracts an oop in the pool for fast instanceof/checkcast
86 private:
87 typeArrayOop _tags; // the tag array describing the constant pool's contents
88 constantPoolCacheOop _cache; // the cache holding interpreter runtime information
89 klassOop _pool_holder; // the corresponding class
90 typeArrayOop _operands; // for variable-sized (InvokeDynamic) nodes, usually empty
91 int _flags; // a few header bits to describe contents for GC
92 int _length; // number of elements in the array
93 volatile bool _is_conc_safe; // if true, safe for concurrent
94 // GC processing
95 // only set to non-zero if constant pool is merged by RedefineClasses
96 int _orig_length;
98 void set_tags(typeArrayOop tags) { oop_store_without_check((oop*)&_tags, tags); }
99 void tag_at_put(int which, jbyte t) { tags()->byte_at_put(which, t); }
100 void release_tag_at_put(int which, jbyte t) { tags()->release_byte_at_put(which, t); }
102 void set_operands(typeArrayOop operands) { oop_store_without_check((oop*)&_operands, operands); }
104 enum FlagBit {
105 FB_has_invokedynamic = 1,
106 FB_has_pseudo_string = 2,
107 FB_has_preresolution = 3
108 };
110 int flags() const { return _flags; }
111 void set_flags(int f) { _flags = f; }
112 bool flag_at(FlagBit fb) const { return (_flags & (1 << (int)fb)) != 0; }
113 void set_flag_at(FlagBit fb);
114 // no clear_flag_at function; they only increase
116 private:
117 intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(constantPoolOopDesc)); }
118 oop* tags_addr() { return (oop*)&_tags; }
119 oop* cache_addr() { return (oop*)&_cache; }
120 oop* operands_addr() { return (oop*)&_operands; }
122 CPSlot slot_at(int which) {
123 assert(is_within_bounds(which), "index out of bounds");
124 // There's a transitional value of zero when converting from
125 // Symbol->0->Klass for G1 when resolving classes and strings.
126 // wait for the value to be non-zero (this is temporary)
127 volatile intptr_t adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which));
128 if (adr == 0 && which != 0) {
129 constantTag t = tag_at(which);
130 if (t.is_unresolved_klass() || t.is_klass() ||
131 t.is_unresolved_string() || t.is_string()) {
132 while ((adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))) == 0);
133 }
134 }
135 return CPSlot(adr);
136 }
138 void slot_at_put(int which, CPSlot s) const {
139 assert(is_within_bounds(which), "index out of bounds");
140 *(intptr_t*)&base()[which] = s.value();
141 }
142 oop* obj_at_addr_raw(int which) const {
143 assert(is_within_bounds(which), "index out of bounds");
144 return (oop*) &base()[which];
145 }
147 void obj_at_put_without_check(int which, oop o) {
148 assert(is_within_bounds(which), "index out of bounds");
149 oop_store_without_check((volatile oop *)obj_at_addr_raw(which), o);
150 }
152 void obj_at_put(int which, oop o) const {
153 assert(is_within_bounds(which), "index out of bounds");
154 oop_store((volatile oop*)obj_at_addr_raw(which), o);
155 }
157 jint* int_at_addr(int which) const {
158 assert(is_within_bounds(which), "index out of bounds");
159 return (jint*) &base()[which];
160 }
162 jlong* long_at_addr(int which) const {
163 assert(is_within_bounds(which), "index out of bounds");
164 return (jlong*) &base()[which];
165 }
167 jfloat* float_at_addr(int which) const {
168 assert(is_within_bounds(which), "index out of bounds");
169 return (jfloat*) &base()[which];
170 }
172 jdouble* double_at_addr(int which) const {
173 assert(is_within_bounds(which), "index out of bounds");
174 return (jdouble*) &base()[which];
175 }
177 public:
178 typeArrayOop tags() const { return _tags; }
179 typeArrayOop operands() const { return _operands; }
181 bool has_pseudo_string() const { return flag_at(FB_has_pseudo_string); }
182 bool has_invokedynamic() const { return flag_at(FB_has_invokedynamic); }
183 bool has_preresolution() const { return flag_at(FB_has_preresolution); }
184 void set_pseudo_string() { set_flag_at(FB_has_pseudo_string); }
185 void set_invokedynamic() { set_flag_at(FB_has_invokedynamic); }
186 void set_preresolution() { set_flag_at(FB_has_preresolution); }
188 // Klass holding pool
189 klassOop pool_holder() const { return _pool_holder; }
190 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); }
191 oop* pool_holder_addr() { return (oop*)&_pool_holder; }
193 // Interpreter runtime support
194 constantPoolCacheOop cache() const { return _cache; }
195 void set_cache(constantPoolCacheOop cache){ oop_store((oop*)&_cache, cache); }
197 // Assembly code support
198 static int tags_offset_in_bytes() { return offset_of(constantPoolOopDesc, _tags); }
199 static int cache_offset_in_bytes() { return offset_of(constantPoolOopDesc, _cache); }
200 static int operands_offset_in_bytes() { return offset_of(constantPoolOopDesc, _operands); }
201 static int pool_holder_offset_in_bytes() { return offset_of(constantPoolOopDesc, _pool_holder); }
203 // Storing constants
205 void klass_at_put(int which, klassOop k) {
206 // Overwrite the old index with a GC friendly value so
207 // that if G1 looks during the transition during oop_store it won't
208 // assert the symbol is not an oop.
209 *obj_at_addr_raw(which) = NULL;
210 assert(k != NULL, "resolved class shouldn't be null");
211 obj_at_put_without_check(which, k);
212 // The interpreter assumes when the tag is stored, the klass is resolved
213 // and the klassOop is a klass rather than a Symbol*, so we need
214 // hardware store ordering here.
215 release_tag_at_put(which, JVM_CONSTANT_Class);
216 if (UseConcMarkSweepGC) {
217 // In case the earlier card-mark was consumed by a concurrent
218 // marking thread before the tag was updated, redirty the card.
219 obj_at_put_without_check(which, k);
220 }
221 }
223 // For temporary use while constructing constant pool
224 void klass_index_at_put(int which, int name_index) {
225 tag_at_put(which, JVM_CONSTANT_ClassIndex);
226 *int_at_addr(which) = name_index;
227 }
229 // Temporary until actual use
230 void unresolved_klass_at_put(int which, Symbol* s) {
231 release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass);
232 slot_at_put(which, s);
233 }
235 void method_handle_index_at_put(int which, int ref_kind, int ref_index) {
236 tag_at_put(which, JVM_CONSTANT_MethodHandle);
237 *int_at_addr(which) = ((jint) ref_index<<16) | ref_kind;
238 }
240 void method_type_index_at_put(int which, int ref_index) {
241 tag_at_put(which, JVM_CONSTANT_MethodType);
242 *int_at_addr(which) = ref_index;
243 }
245 void invoke_dynamic_at_put(int which, int bootstrap_specifier_index, int name_and_type_index) {
246 tag_at_put(which, JVM_CONSTANT_InvokeDynamic);
247 *int_at_addr(which) = ((jint) name_and_type_index<<16) | bootstrap_specifier_index;
248 }
250 // Temporary until actual use
251 void unresolved_string_at_put(int which, Symbol* s) {
252 release_tag_at_put(which, JVM_CONSTANT_UnresolvedString);
253 slot_at_put(which, s);
254 }
256 void int_at_put(int which, jint i) {
257 tag_at_put(which, JVM_CONSTANT_Integer);
258 *int_at_addr(which) = i;
259 }
261 void long_at_put(int which, jlong l) {
262 tag_at_put(which, JVM_CONSTANT_Long);
263 // *long_at_addr(which) = l;
264 Bytes::put_native_u8((address)long_at_addr(which), *((u8*) &l));
265 }
267 void float_at_put(int which, jfloat f) {
268 tag_at_put(which, JVM_CONSTANT_Float);
269 *float_at_addr(which) = f;
270 }
272 void double_at_put(int which, jdouble d) {
273 tag_at_put(which, JVM_CONSTANT_Double);
274 // *double_at_addr(which) = d;
275 // u8 temp = *(u8*) &d;
276 Bytes::put_native_u8((address) double_at_addr(which), *((u8*) &d));
277 }
279 Symbol** symbol_at_addr(int which) const {
280 assert(is_within_bounds(which), "index out of bounds");
281 return (Symbol**) &base()[which];
282 }
284 void symbol_at_put(int which, Symbol* s) {
285 assert(s->refcount() != 0, "should have nonzero refcount");
286 tag_at_put(which, JVM_CONSTANT_Utf8);
287 slot_at_put(which, s);
288 }
290 void string_at_put(int which, oop str) {
291 // Overwrite the old index with a GC friendly value so
292 // that if G1 looks during the transition during oop_store it won't
293 // assert the symbol is not an oop.
294 *obj_at_addr_raw(which) = NULL;
295 assert(str != NULL, "resolved string shouldn't be null");
296 obj_at_put(which, str);
297 release_tag_at_put(which, JVM_CONSTANT_String);
298 if (UseConcMarkSweepGC) {
299 // In case the earlier card-mark was consumed by a concurrent
300 // marking thread before the tag was updated, redirty the card.
301 obj_at_put_without_check(which, str);
302 }
303 }
305 void object_at_put(int which, oop str) {
306 obj_at_put(which, str);
307 release_tag_at_put(which, JVM_CONSTANT_Object);
308 if (UseConcMarkSweepGC) {
309 // In case the earlier card-mark was consumed by a concurrent
310 // marking thread before the tag was updated, redirty the card.
311 obj_at_put_without_check(which, str);
312 }
313 }
315 // For temporary use while constructing constant pool
316 void string_index_at_put(int which, int string_index) {
317 tag_at_put(which, JVM_CONSTANT_StringIndex);
318 *int_at_addr(which) = string_index;
319 }
321 void field_at_put(int which, int class_index, int name_and_type_index) {
322 tag_at_put(which, JVM_CONSTANT_Fieldref);
323 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;
324 }
326 void method_at_put(int which, int class_index, int name_and_type_index) {
327 tag_at_put(which, JVM_CONSTANT_Methodref);
328 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;
329 }
331 void interface_method_at_put(int which, int class_index, int name_and_type_index) {
332 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref);
333 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; // Not so nice
334 }
336 void name_and_type_at_put(int which, int name_index, int signature_index) {
337 tag_at_put(which, JVM_CONSTANT_NameAndType);
338 *int_at_addr(which) = ((jint) signature_index<<16) | name_index; // Not so nice
339 }
341 // Tag query
343 constantTag tag_at(int which) const { return (constantTag)tags()->byte_at_acquire(which); }
345 // Whether the entry is a pointer that must be GC'd.
346 bool is_pointer_entry(int which) {
347 constantTag tag = tag_at(which);
348 return tag.is_klass() ||
349 tag.is_string() ||
350 tag.is_object();
351 }
353 // Whether the entry points to an object for ldc (resolved or not)
354 bool is_object_entry(int which) {
355 constantTag tag = tag_at(which);
356 return is_pointer_entry(which) ||
357 tag.is_unresolved_klass() ||
358 tag.is_unresolved_string() ||
359 tag.is_symbol();
360 }
362 // Fetching constants
364 klassOop klass_at(int which, TRAPS) {
365 constantPoolHandle h_this(THREAD, this);
366 return klass_at_impl(h_this, which, CHECK_NULL);
367 }
369 Symbol* klass_name_at(int which); // Returns the name, w/o resolving.
371 klassOop resolved_klass_at(int which) { // Used by Compiler
372 guarantee(tag_at(which).is_klass(), "Corrupted constant pool");
373 // Must do an acquire here in case another thread resolved the klass
374 // behind our back, lest we later load stale values thru the oop.
375 return klassOop(CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop());
376 }
378 // This method should only be used with a cpool lock or during parsing or gc
379 Symbol* unresolved_klass_at(int which) { // Temporary until actual use
380 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();
381 // check that the klass is still unresolved.
382 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool");
383 return s;
384 }
386 // RedefineClasses() API support:
387 Symbol* klass_at_noresolve(int which) { return klass_name_at(which); }
389 jint int_at(int which) {
390 assert(tag_at(which).is_int(), "Corrupted constant pool");
391 return *int_at_addr(which);
392 }
394 jlong long_at(int which) {
395 assert(tag_at(which).is_long(), "Corrupted constant pool");
396 // return *long_at_addr(which);
397 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
398 return *((jlong*)&tmp);
399 }
401 jfloat float_at(int which) {
402 assert(tag_at(which).is_float(), "Corrupted constant pool");
403 return *float_at_addr(which);
404 }
406 jdouble double_at(int which) {
407 assert(tag_at(which).is_double(), "Corrupted constant pool");
408 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
409 return *((jdouble*)&tmp);
410 }
412 Symbol* symbol_at(int which) {
413 assert(tag_at(which).is_utf8(), "Corrupted constant pool");
414 return slot_at(which).get_symbol();
415 }
417 oop string_at(int which, TRAPS) {
418 constantPoolHandle h_this(THREAD, this);
419 return string_at_impl(h_this, which, CHECK_NULL);
420 }
422 oop object_at(int which) {
423 assert(tag_at(which).is_object(), "Corrupted constant pool");
424 return slot_at(which).get_oop();
425 }
427 // A "pseudo-string" is an non-string oop that has found is way into
428 // a String entry.
429 // Under EnableInvokeDynamic this can happen if the user patches a live
430 // object into a CONSTANT_String entry of an anonymous class.
431 // Method oops internally created for method handles may also
432 // use pseudo-strings to link themselves to related metaobjects.
434 bool is_pseudo_string_at(int which);
436 oop pseudo_string_at(int which) {
437 assert(tag_at(which).is_string(), "Corrupted constant pool");
438 return slot_at(which).get_oop();
439 }
441 void pseudo_string_at_put(int which, oop x) {
442 assert(EnableInvokeDynamic, "");
443 set_pseudo_string(); // mark header
444 assert(tag_at(which).is_string() || tag_at(which).is_unresolved_string(), "Corrupted constant pool");
445 string_at_put(which, x); // this works just fine
446 }
448 // only called when we are sure a string entry is already resolved (via an
449 // earlier string_at call.
450 oop resolved_string_at(int which) {
451 assert(tag_at(which).is_string(), "Corrupted constant pool");
452 // Must do an acquire here in case another thread resolved the klass
453 // behind our back, lest we later load stale values thru the oop.
454 return CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop();
455 }
457 // This method should only be used with a cpool lock or during parsing or gc
458 Symbol* unresolved_string_at(int which) { // Temporary until actual use
459 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();
460 // check that the string is still unresolved.
461 assert(tag_at(which).is_unresolved_string(), "Corrupted constant pool");
462 return s;
463 }
465 // Returns an UTF8 for a CONSTANT_String entry at a given index.
466 // UTF8 char* representation was chosen to avoid conversion of
467 // java_lang_Strings at resolved entries into Symbol*s
468 // or vice versa.
469 // Caller is responsible for checking for pseudo-strings.
470 char* string_at_noresolve(int which);
472 jint name_and_type_at(int which) {
473 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool");
474 return *int_at_addr(which);
475 }
477 int method_handle_ref_kind_at(int which) {
478 assert(tag_at(which).is_method_handle(), "Corrupted constant pool");
479 return extract_low_short_from_int(*int_at_addr(which)); // mask out unwanted ref_index bits
480 }
481 int method_handle_index_at(int which) {
482 assert(tag_at(which).is_method_handle(), "Corrupted constant pool");
483 return extract_high_short_from_int(*int_at_addr(which)); // shift out unwanted ref_kind bits
484 }
485 int method_type_index_at(int which) {
486 assert(tag_at(which).is_method_type(), "Corrupted constant pool");
487 return *int_at_addr(which);
488 }
489 // Derived queries:
490 Symbol* method_handle_name_ref_at(int which) {
491 int member = method_handle_index_at(which);
492 return impl_name_ref_at(member, true);
493 }
494 Symbol* method_handle_signature_ref_at(int which) {
495 int member = method_handle_index_at(which);
496 return impl_signature_ref_at(member, true);
497 }
498 int method_handle_klass_index_at(int which) {
499 int member = method_handle_index_at(which);
500 return impl_klass_ref_index_at(member, true);
501 }
502 Symbol* method_type_signature_at(int which) {
503 int sym = method_type_index_at(which);
504 return symbol_at(sym);
505 }
507 int invoke_dynamic_name_and_type_ref_index_at(int which) {
508 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
509 return extract_high_short_from_int(*int_at_addr(which));
510 }
511 int invoke_dynamic_bootstrap_specifier_index(int which) {
512 assert(tag_at(which).value() == JVM_CONSTANT_InvokeDynamic, "Corrupted constant pool");
513 return extract_low_short_from_int(*int_at_addr(which));
514 }
515 int invoke_dynamic_operand_base(int which) {
516 int bootstrap_specifier_index = invoke_dynamic_bootstrap_specifier_index(which);
517 return operand_offset_at(operands(), bootstrap_specifier_index);
518 }
519 // The first part of the operands array consists of an index into the second part.
520 // Extract a 32-bit index value from the first part.
521 static int operand_offset_at(typeArrayOop operands, int bootstrap_specifier_index) {
522 int n = (bootstrap_specifier_index * 2);
523 assert(n >= 0 && n+2 <= operands->length(), "oob");
524 // The first 32-bit index points to the beginning of the second part
525 // of the operands array. Make sure this index is in the first part.
526 DEBUG_ONLY(int second_part = build_int_from_shorts(operands->short_at(0),
527 operands->short_at(1)));
528 assert(second_part == 0 || n+2 <= second_part, "oob (2)");
529 int offset = build_int_from_shorts(operands->short_at(n+0),
530 operands->short_at(n+1));
531 // The offset itself must point into the second part of the array.
532 assert(offset == 0 || offset >= second_part && offset <= operands->length(), "oob (3)");
533 return offset;
534 }
535 static void operand_offset_at_put(typeArrayOop operands, int bootstrap_specifier_index, int offset) {
536 int n = bootstrap_specifier_index * 2;
537 assert(n >= 0 && n+2 <= operands->length(), "oob");
538 operands->short_at_put(n+0, extract_low_short_from_int(offset));
539 operands->short_at_put(n+1, extract_high_short_from_int(offset));
540 }
541 static int operand_array_length(typeArrayOop operands) {
542 if (operands == NULL || operands->length() == 0) return 0;
543 int second_part = operand_offset_at(operands, 0);
544 return (second_part / 2);
545 }
547 #ifdef ASSERT
548 // operand tuples fit together exactly, end to end
549 static int operand_limit_at(typeArrayOop operands, int bootstrap_specifier_index) {
550 int nextidx = bootstrap_specifier_index + 1;
551 if (nextidx == operand_array_length(operands))
552 return operands->length();
553 else
554 return operand_offset_at(operands, nextidx);
555 }
556 int invoke_dynamic_operand_limit(int which) {
557 int bootstrap_specifier_index = invoke_dynamic_bootstrap_specifier_index(which);
558 return operand_limit_at(operands(), bootstrap_specifier_index);
559 }
560 #endif //ASSERT
562 // layout of InvokeDynamic bootstrap method specifier (in second part of operands array):
563 enum {
564 _indy_bsm_offset = 0, // CONSTANT_MethodHandle bsm
565 _indy_argc_offset = 1, // u2 argc
566 _indy_argv_offset = 2 // u2 argv[argc]
567 };
568 int invoke_dynamic_bootstrap_method_ref_index_at(int which) {
569 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
570 int op_base = invoke_dynamic_operand_base(which);
571 return operands()->short_at(op_base + _indy_bsm_offset);
572 }
573 int invoke_dynamic_argument_count_at(int which) {
574 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
575 int op_base = invoke_dynamic_operand_base(which);
576 int argc = operands()->short_at(op_base + _indy_argc_offset);
577 DEBUG_ONLY(int end_offset = op_base + _indy_argv_offset + argc;
578 int next_offset = invoke_dynamic_operand_limit(which));
579 assert(end_offset == next_offset, "matched ending");
580 return argc;
581 }
582 int invoke_dynamic_argument_index_at(int which, int j) {
583 int op_base = invoke_dynamic_operand_base(which);
584 DEBUG_ONLY(int argc = operands()->short_at(op_base + _indy_argc_offset));
585 assert((uint)j < (uint)argc, "oob");
586 return operands()->short_at(op_base + _indy_argv_offset + j);
587 }
589 // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve,
590 // name_and_type_ref_index_at) all expect to be passed indices obtained
591 // directly from the bytecode.
592 // If the indices are meant to refer to fields or methods, they are
593 // actually rewritten constant pool cache indices.
594 // The routine remap_instruction_operand_from_cache manages the adjustment
595 // of these values back to constant pool indices.
597 // There are also "uncached" versions which do not adjust the operand index; see below.
599 // FIXME: Consider renaming these with a prefix "cached_" to make the distinction clear.
600 // In a few cases (the verifier) there are uses before a cpcache has been built,
601 // which are handled by a dynamic check in remap_instruction_operand_from_cache.
602 // FIXME: Remove the dynamic check, and adjust all callers to specify the correct mode.
604 // Lookup for entries consisting of (klass_index, name_and_type index)
605 klassOop klass_ref_at(int which, TRAPS);
606 Symbol* klass_ref_at_noresolve(int which);
607 Symbol* name_ref_at(int which) { return impl_name_ref_at(which, false); }
608 Symbol* signature_ref_at(int which) { return impl_signature_ref_at(which, false); }
610 int klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, false); }
611 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); }
613 // Lookup for entries consisting of (name_index, signature_index)
614 int name_ref_index_at(int which_nt); // == low-order jshort of name_and_type_at(which_nt)
615 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt)
617 BasicType basic_type_for_signature_at(int which);
619 // Resolve string constants (to prevent allocation during compilation)
620 void resolve_string_constants(TRAPS) {
621 constantPoolHandle h_this(THREAD, this);
622 resolve_string_constants_impl(h_this, CHECK);
623 }
625 private:
626 enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 };
627 public:
629 // Resolve late bound constants.
630 oop resolve_constant_at(int index, TRAPS) {
631 constantPoolHandle h_this(THREAD, this);
632 return resolve_constant_at_impl(h_this, index, _no_index_sentinel, THREAD);
633 }
635 oop resolve_cached_constant_at(int cache_index, TRAPS) {
636 constantPoolHandle h_this(THREAD, this);
637 return resolve_constant_at_impl(h_this, _no_index_sentinel, cache_index, THREAD);
638 }
640 oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) {
641 constantPoolHandle h_this(THREAD, this);
642 return resolve_constant_at_impl(h_this, pool_index, _possible_index_sentinel, THREAD);
643 }
645 oop resolve_bootstrap_specifier_at(int index, TRAPS) {
646 constantPoolHandle h_this(THREAD, this);
647 return resolve_bootstrap_specifier_at_impl(h_this, index, THREAD);
648 }
650 // Klass name matches name at offset
651 bool klass_name_at_matches(instanceKlassHandle k, int which);
653 // Sizing
654 int length() const { return _length; }
655 void set_length(int length) { _length = length; }
657 // Tells whether index is within bounds.
658 bool is_within_bounds(int index) const {
659 return 0 <= index && index < length();
660 }
662 static int header_size() { return sizeof(constantPoolOopDesc)/HeapWordSize; }
663 static int object_size(int length) { return align_object_size(header_size() + length); }
664 int object_size() { return object_size(length()); }
666 bool is_conc_safe() { return _is_conc_safe; }
667 void set_is_conc_safe(bool v) { _is_conc_safe = v; }
669 friend class constantPoolKlass;
670 friend class ClassFileParser;
671 friend class SystemDictionary;
673 // Used by compiler to prevent classloading.
674 static methodOop method_at_if_loaded (constantPoolHandle this_oop, int which);
675 static bool has_appendix_at_if_loaded (constantPoolHandle this_oop, int which);
676 static oop appendix_at_if_loaded (constantPoolHandle this_oop, int which);
677 static klassOop klass_at_if_loaded (constantPoolHandle this_oop, int which);
678 static klassOop klass_ref_at_if_loaded (constantPoolHandle this_oop, int which);
679 // Same as above - but does LinkResolving.
680 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS);
682 // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the
683 // future by other Java code. These take constant pool indices rather than
684 // constant pool cache indices as do the peer methods above.
685 Symbol* uncached_klass_ref_at_noresolve(int which);
686 Symbol* uncached_name_ref_at(int which) { return impl_name_ref_at(which, true); }
687 Symbol* uncached_signature_ref_at(int which) { return impl_signature_ref_at(which, true); }
688 int uncached_klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, true); }
689 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); }
691 // Sharing
692 int pre_resolve_shared_klasses(TRAPS);
693 void shared_symbols_iterate(SymbolClosure* closure0);
694 void shared_tags_iterate(OopClosure* closure0);
695 void shared_strings_iterate(OopClosure* closure0);
697 // Debugging
698 const char* printable_name_at(int which) PRODUCT_RETURN0;
700 #ifdef ASSERT
701 enum { CPCACHE_INDEX_TAG = 0x10000 }; // helps keep CP cache indices distinct from CP indices
702 #else
703 enum { CPCACHE_INDEX_TAG = 0 }; // in product mode, this zero value is a no-op
704 #endif //ASSERT
706 static int get_cpcache_index(int index) { return index - CPCACHE_INDEX_TAG; }
708 private:
710 Symbol* impl_name_ref_at(int which, bool uncached);
711 Symbol* impl_signature_ref_at(int which, bool uncached);
712 int impl_klass_ref_index_at(int which, bool uncached);
713 int impl_name_and_type_ref_index_at(int which, bool uncached);
715 int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG
717 // Used while constructing constant pool (only by ClassFileParser)
718 jint klass_index_at(int which) {
719 assert(tag_at(which).is_klass_index(), "Corrupted constant pool");
720 return *int_at_addr(which);
721 }
723 jint string_index_at(int which) {
724 assert(tag_at(which).is_string_index(), "Corrupted constant pool");
725 return *int_at_addr(which);
726 }
728 // Performs the LinkResolver checks
729 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS);
731 // Implementation of methods that needs an exposed 'this' pointer, in order to
732 // handle GC while executing the method
733 static klassOop klass_at_impl(constantPoolHandle this_oop, int which, TRAPS);
734 static oop string_at_impl(constantPoolHandle this_oop, int which, TRAPS);
736 // Resolve string constants (to prevent allocation during compilation)
737 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS);
739 static oop resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS);
740 static oop resolve_bootstrap_specifier_at_impl(constantPoolHandle this_oop, int index, TRAPS);
742 public:
743 // Merging constantPoolOop support:
744 bool compare_entry_to(int index1, constantPoolHandle cp2, int index2, TRAPS);
745 void copy_cp_to(int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS) {
746 constantPoolHandle h_this(THREAD, this);
747 copy_cp_to_impl(h_this, start_i, end_i, to_cp, to_i, THREAD);
748 }
749 static void copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS);
750 static void copy_entry_to(constantPoolHandle from_cp, int from_i, constantPoolHandle to_cp, int to_i, TRAPS);
751 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS);
752 int orig_length() const { return _orig_length; }
753 void set_orig_length(int orig_length) { _orig_length = orig_length; }
755 // Decrease ref counts of symbols that are in the constant pool
756 // when the holder class is unloaded
757 void unreference_symbols();
759 // JVMTI accesss - GetConstantPool, RetransformClasses, ...
760 friend class JvmtiConstantPoolReconstituter;
762 private:
763 jint cpool_entry_size(jint idx);
764 jint hash_entries_to(SymbolHashMap *symmap, SymbolHashMap *classmap);
766 // Copy cpool bytes into byte array.
767 // Returns:
768 // int > 0, count of the raw cpool bytes that have been copied
769 // 0, OutOfMemory error
770 // -1, Internal error
771 int copy_cpool_bytes(int cpool_size,
772 SymbolHashMap* tbl,
773 unsigned char *bytes);
774 };
776 class SymbolHashMapEntry : public CHeapObj<mtSymbol> {
777 private:
778 unsigned int _hash; // 32-bit hash for item
779 SymbolHashMapEntry* _next; // Next element in the linked list for this bucket
780 Symbol* _symbol; // 1-st part of the mapping: symbol => value
781 u2 _value; // 2-nd part of the mapping: symbol => value
783 public:
784 unsigned int hash() const { return _hash; }
785 void set_hash(unsigned int hash) { _hash = hash; }
787 SymbolHashMapEntry* next() const { return _next; }
788 void set_next(SymbolHashMapEntry* next) { _next = next; }
790 Symbol* symbol() const { return _symbol; }
791 void set_symbol(Symbol* sym) { _symbol = sym; }
793 u2 value() const { return _value; }
794 void set_value(u2 value) { _value = value; }
796 SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value)
797 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {}
799 }; // End SymbolHashMapEntry class
802 class SymbolHashMapBucket : public CHeapObj<mtSymbol> {
804 private:
805 SymbolHashMapEntry* _entry;
807 public:
808 SymbolHashMapEntry* entry() const { return _entry; }
809 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; }
810 void clear() { _entry = NULL; }
812 }; // End SymbolHashMapBucket class
815 class SymbolHashMap: public CHeapObj<mtSymbol> {
817 private:
818 // Default number of entries in the table
819 enum SymbolHashMap_Constants {
820 _Def_HashMap_Size = 256
821 };
823 int _table_size;
824 SymbolHashMapBucket* _buckets;
826 void initialize_table(int table_size) {
827 _table_size = table_size;
828 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size, mtSymbol);
829 for (int index = 0; index < table_size; index++) {
830 _buckets[index].clear();
831 }
832 }
834 public:
836 int table_size() const { return _table_size; }
838 SymbolHashMap() { initialize_table(_Def_HashMap_Size); }
839 SymbolHashMap(int table_size) { initialize_table(table_size); }
841 // hash P(31) from Kernighan & Ritchie
842 static unsigned int compute_hash(const char* str, int len) {
843 unsigned int hash = 0;
844 while (len-- > 0) {
845 hash = 31*hash + (unsigned) *str;
846 str++;
847 }
848 return hash;
849 }
851 SymbolHashMapEntry* bucket(int i) {
852 return _buckets[i].entry();
853 }
855 void add_entry(Symbol* sym, u2 value);
856 SymbolHashMapEntry* find_entry(Symbol* sym);
858 u2 symbol_to_value(Symbol* sym) {
859 SymbolHashMapEntry *entry = find_entry(sym);
860 return (entry == NULL) ? 0 : entry->value();
861 }
863 ~SymbolHashMap() {
864 SymbolHashMapEntry* next;
865 for (int i = 0; i < _table_size; i++) {
866 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) {
867 next = cur->next();
868 delete(cur);
869 }
870 }
871 delete _buckets;
872 }
873 }; // End SymbolHashMap class
875 #endif // SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP