1 /*
2 * Copyright 1997-2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 // A constantPool is an array containing class constants as described in the
26 // class file.
27 //
28 // Most of the constant pool entries are written during class parsing, which
29 // is safe. For klass and string types, the constant pool entry is
30 // modified when the entry is resolved. If a klass or string constant pool
31 // entry is read without a lock, only the resolved state guarantees that
32 // the entry in the constant pool is a klass or String object and
33 // not a symbolOop.
34
35 class SymbolHashMap;
36
37 class constantPoolOopDesc : public oopDesc {
38 friend class VMStructs;
39 friend class BytecodeInterpreter; // Directly extracts an oop in the pool for fast instanceof/checkcast
40 private:
41 typeArrayOop _tags; // the tag array describing the constant pool's contents
42 constantPoolCacheOop _cache; // the cache holding interpreter runtime information
43 klassOop _pool_holder; // the corresponding class
44 int _flags; // a few header bits to describe contents for GC
45 int _length; // number of elements in the array
46 volatile bool _is_conc_safe; // if true, safe for concurrent
47 // GC processing
48 // only set to non-zero if constant pool is merged by RedefineClasses
49 int _orig_length;
50
51 void set_tags(typeArrayOop tags) { oop_store_without_check((oop*)&_tags, tags); }
52 void tag_at_put(int which, jbyte t) { tags()->byte_at_put(which, t); }
53 void release_tag_at_put(int which, jbyte t) { tags()->release_byte_at_put(which, t); }
54
55 enum FlagBit {
56 FB_has_invokedynamic = 1,
57 FB_has_pseudo_string = 2
58 };
59
60 int flags() const { return _flags; }
61 void set_flags(int f) { _flags = f; }
62 bool flag_at(FlagBit fb) const { return (_flags & (1 << (int)fb)) != 0; }
63 void set_flag_at(FlagBit fb);
64 // no clear_flag_at function; they only increase
65
66 private:
67 intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(constantPoolOopDesc)); }
68 oop* tags_addr() { return (oop*)&_tags; }
69 oop* cache_addr() { return (oop*)&_cache; }
70
71 oop* obj_at_addr(int which) const {
72 assert(is_within_bounds(which), "index out of bounds");
73 return (oop*) &base()[which];
74 }
75
76 jint* int_at_addr(int which) const {
77 assert(is_within_bounds(which), "index out of bounds");
78 return (jint*) &base()[which];
79 }
80
81 jlong* long_at_addr(int which) const {
82 assert(is_within_bounds(which), "index out of bounds");
83 return (jlong*) &base()[which];
84 }
85
86 jfloat* float_at_addr(int which) const {
87 assert(is_within_bounds(which), "index out of bounds");
88 return (jfloat*) &base()[which];
89 }
90
91 jdouble* double_at_addr(int which) const {
92 assert(is_within_bounds(which), "index out of bounds");
93 return (jdouble*) &base()[which];
94 }
95
96 public:
97 typeArrayOop tags() const { return _tags; }
98
99 bool has_pseudo_string() const { return flag_at(FB_has_pseudo_string); }
100 bool has_invokedynamic() const { return flag_at(FB_has_invokedynamic); }
101 void set_pseudo_string() { set_flag_at(FB_has_pseudo_string); }
102 void set_invokedynamic() { set_flag_at(FB_has_invokedynamic); }
103
104 // Klass holding pool
105 klassOop pool_holder() const { return _pool_holder; }
106 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); }
107 oop* pool_holder_addr() { return (oop*)&_pool_holder; }
108
109 // Interpreter runtime support
110 constantPoolCacheOop cache() const { return _cache; }
111 void set_cache(constantPoolCacheOop cache){ oop_store((oop*)&_cache, cache); }
112
113 // Assembly code support
114 static int tags_offset_in_bytes() { return offset_of(constantPoolOopDesc, _tags); }
115 static int cache_offset_in_bytes() { return offset_of(constantPoolOopDesc, _cache); }
116 static int pool_holder_offset_in_bytes() { return offset_of(constantPoolOopDesc, _pool_holder); }
117
118 // Storing constants
119
120 void klass_at_put(int which, klassOop k) {
121 oop_store_without_check((volatile oop *)obj_at_addr(which), oop(k));
122 // The interpreter assumes when the tag is stored, the klass is resolved
123 // and the klassOop is a klass rather than a symbolOop, so we need
124 // hardware store ordering here.
125 release_tag_at_put(which, JVM_CONSTANT_Class);
126 if (UseConcMarkSweepGC) {
127 // In case the earlier card-mark was consumed by a concurrent
128 // marking thread before the tag was updated, redirty the card.
129 oop_store_without_check((volatile oop *)obj_at_addr(which), oop(k));
130 }
131 }
132
133 // For temporary use while constructing constant pool
134 void klass_index_at_put(int which, int name_index) {
135 tag_at_put(which, JVM_CONSTANT_ClassIndex);
136 *int_at_addr(which) = name_index;
137 }
138
139 // Temporary until actual use
140 void unresolved_klass_at_put(int which, symbolOop s) {
141 // Overwrite the old index with a GC friendly value so
142 // that if GC looks during the transition it won't try
143 // to treat a small integer as oop.
144 *obj_at_addr(which) = NULL;
145 release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass);
146 oop_store_without_check(obj_at_addr(which), oop(s));
147 }
148
149 // Temporary until actual use
150 void unresolved_string_at_put(int which, symbolOop s) {
151 *obj_at_addr(which) = NULL;
152 release_tag_at_put(which, JVM_CONSTANT_UnresolvedString);
153 oop_store_without_check(obj_at_addr(which), oop(s));
154 }
155
156 void int_at_put(int which, jint i) {
157 tag_at_put(which, JVM_CONSTANT_Integer);
158 *int_at_addr(which) = i;
159 }
160
161 void long_at_put(int which, jlong l) {
162 tag_at_put(which, JVM_CONSTANT_Long);
163 // *long_at_addr(which) = l;
164 Bytes::put_native_u8((address)long_at_addr(which), *((u8*) &l));
165 }
166
167 void float_at_put(int which, jfloat f) {
168 tag_at_put(which, JVM_CONSTANT_Float);
169 *float_at_addr(which) = f;
170 }
171
172 void double_at_put(int which, jdouble d) {
173 tag_at_put(which, JVM_CONSTANT_Double);
174 // *double_at_addr(which) = d;
175 // u8 temp = *(u8*) &d;
176 Bytes::put_native_u8((address) double_at_addr(which), *((u8*) &d));
177 }
178
179 void symbol_at_put(int which, symbolOop s) {
180 tag_at_put(which, JVM_CONSTANT_Utf8);
181 oop_store_without_check(obj_at_addr(which), oop(s));
182 }
183
184 void string_at_put(int which, oop str) {
185 oop_store((volatile oop*)obj_at_addr(which), str);
186 release_tag_at_put(which, JVM_CONSTANT_String);
187 if (UseConcMarkSweepGC) {
188 // In case the earlier card-mark was consumed by a concurrent
189 // marking thread before the tag was updated, redirty the card.
190 oop_store_without_check((volatile oop *)obj_at_addr(which), str);
191 }
192 }
193
194 void object_at_put(int which, oop str) {
195 oop_store((volatile oop*) obj_at_addr(which), str);
196 release_tag_at_put(which, JVM_CONSTANT_Object);
197 if (UseConcMarkSweepGC) {
198 // In case the earlier card-mark was consumed by a concurrent
199 // marking thread before the tag was updated, redirty the card.
200 oop_store_without_check((volatile oop*) obj_at_addr(which), str);
201 }
202 }
203
204 // For temporary use while constructing constant pool
205 void string_index_at_put(int which, int string_index) {
206 tag_at_put(which, JVM_CONSTANT_StringIndex);
207 *int_at_addr(which) = string_index;
208 }
209
210 void field_at_put(int which, int class_index, int name_and_type_index) {
211 tag_at_put(which, JVM_CONSTANT_Fieldref);
212 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;
213 }
214
215 void method_at_put(int which, int class_index, int name_and_type_index) {
216 tag_at_put(which, JVM_CONSTANT_Methodref);
217 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;
218 }
219
220 void interface_method_at_put(int which, int class_index, int name_and_type_index) {
221 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref);
222 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; // Not so nice
223 }
224
225 void name_and_type_at_put(int which, int name_index, int signature_index) {
226 tag_at_put(which, JVM_CONSTANT_NameAndType);
227 *int_at_addr(which) = ((jint) signature_index<<16) | name_index; // Not so nice
228 }
229
230 // Tag query
231
232 constantTag tag_at(int which) const { return (constantTag)tags()->byte_at_acquire(which); }
233
234 // Whether the entry is a pointer that must be GC'd.
235 bool is_pointer_entry(int which) {
236 constantTag tag = tag_at(which);
237 return tag.is_klass() ||
238 tag.is_unresolved_klass() ||
239 tag.is_symbol() ||
240 tag.is_unresolved_string() ||
241 tag.is_string() ||
242 tag.is_object();
243 }
244
245 // Fetching constants
246
247 klassOop klass_at(int which, TRAPS) {
248 constantPoolHandle h_this(THREAD, this);
249 return klass_at_impl(h_this, which, CHECK_NULL);
250 }
251
252 symbolOop klass_name_at(int which); // Returns the name, w/o resolving.
253
254 klassOop resolved_klass_at(int which) { // Used by Compiler
255 guarantee(tag_at(which).is_klass(), "Corrupted constant pool");
256 // Must do an acquire here in case another thread resolved the klass
257 // behind our back, lest we later load stale values thru the oop.
258 return klassOop((oop)OrderAccess::load_ptr_acquire(obj_at_addr(which)));
259 }
260
261 // This method should only be used with a cpool lock or during parsing or gc
262 symbolOop unresolved_klass_at(int which) { // Temporary until actual use
263 symbolOop s = symbolOop((oop)OrderAccess::load_ptr_acquire(obj_at_addr(which)));
264 // check that the klass is still unresolved.
265 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool");
266 return s;
267 }
268
269 // RedefineClasses() API support:
270 symbolOop klass_at_noresolve(int which) { return klass_name_at(which); }
271
272 jint int_at(int which) {
273 assert(tag_at(which).is_int(), "Corrupted constant pool");
274 return *int_at_addr(which);
275 }
276
277 jlong long_at(int which) {
278 assert(tag_at(which).is_long(), "Corrupted constant pool");
279 // return *long_at_addr(which);
280 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
281 return *((jlong*)&tmp);
282 }
283
284 jfloat float_at(int which) {
285 assert(tag_at(which).is_float(), "Corrupted constant pool");
286 return *float_at_addr(which);
287 }
288
289 jdouble double_at(int which) {
290 assert(tag_at(which).is_double(), "Corrupted constant pool");
291 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
292 return *((jdouble*)&tmp);
293 }
294
295 symbolOop symbol_at(int which) {
296 assert(tag_at(which).is_utf8(), "Corrupted constant pool");
297 return symbolOop(*obj_at_addr(which));
298 }
299
300 oop string_at(int which, TRAPS) {
301 constantPoolHandle h_this(THREAD, this);
302 return string_at_impl(h_this, which, CHECK_NULL);
303 }
304
305 oop object_at(int which) {
306 assert(tag_at(which).is_object(), "Corrupted constant pool");
307 return *obj_at_addr(which);
308 }
309
310 // A "pseudo-string" is an non-string oop that has found is way into
311 // a String entry.
312 // Under AnonymousClasses this can happen if the user patches a live
313 // object into a CONSTANT_String entry of an anonymous class.
314 // Method oops internally created for method handles may also
315 // use pseudo-strings to link themselves to related metaobjects.
316
317 bool is_pseudo_string_at(int which);
318
319 oop pseudo_string_at(int which) {
320 assert(tag_at(which).is_string(), "Corrupted constant pool");
321 return *obj_at_addr(which);
322 }
323
324 void pseudo_string_at_put(int which, oop x) {
325 assert(AnonymousClasses, "");
326 set_pseudo_string(); // mark header
327 assert(tag_at(which).is_string() || tag_at(which).is_unresolved_string(), "Corrupted constant pool");
328 string_at_put(which, x); // this works just fine
329 }
330
331 // only called when we are sure a string entry is already resolved (via an
332 // earlier string_at call.
333 oop resolved_string_at(int which) {
334 assert(tag_at(which).is_string(), "Corrupted constant pool");
335 // Must do an acquire here in case another thread resolved the klass
336 // behind our back, lest we later load stale values thru the oop.
337 return (oop)OrderAccess::load_ptr_acquire(obj_at_addr(which));
338 }
339
340 // This method should only be used with a cpool lock or during parsing or gc
341 symbolOop unresolved_string_at(int which) { // Temporary until actual use
342 symbolOop s = symbolOop((oop)OrderAccess::load_ptr_acquire(obj_at_addr(which)));
343 // check that the string is still unresolved.
344 assert(tag_at(which).is_unresolved_string(), "Corrupted constant pool");
345 return s;
346 }
347
348 // Returns an UTF8 for a CONSTANT_String entry at a given index.
349 // UTF8 char* representation was chosen to avoid conversion of
350 // java_lang_Strings at resolved entries into symbolOops
351 // or vice versa.
352 // Caller is responsible for checking for pseudo-strings.
353 char* string_at_noresolve(int which);
354
355 jint name_and_type_at(int which) {
356 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool");
357 return *int_at_addr(which);
358 }
359
360 // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve,
361 // name_and_type_ref_index_at) all expect to be passed indices obtained
362 // directly from the bytecode, and extracted according to java byte order.
363 // If the indices are meant to refer to fields or methods, they are
364 // actually potentially byte-swapped, rewritten constant pool cache indices.
365 // The routine remap_instruction_operand_from_cache manages the adjustment
366 // of these values back to constant pool indices.
367
368 // There are also "uncached" versions which do not adjust the operand index; see below.
369
370 // Lookup for entries consisting of (klass_index, name_and_type index)
371 klassOop klass_ref_at(int which, TRAPS);
372 symbolOop klass_ref_at_noresolve(int which);
373 symbolOop name_ref_at(int which) { return impl_name_ref_at(which, false); }
374 symbolOop signature_ref_at(int which) { return impl_signature_ref_at(which, false); }
375
376 int klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, false); }
377 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); }
378
379 // Lookup for entries consisting of (name_index, signature_index)
380 int name_ref_index_at(int which_nt); // == low-order jshort of name_and_type_at(which_nt)
381 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt)
382
383 BasicType basic_type_for_signature_at(int which);
384
385 // Resolve string constants (to prevent allocation during compilation)
386 void resolve_string_constants(TRAPS) {
387 constantPoolHandle h_this(THREAD, this);
388 resolve_string_constants_impl(h_this, CHECK);
389 }
390
391 // Klass name matches name at offset
392 bool klass_name_at_matches(instanceKlassHandle k, int which);
393
394 // Sizing
395 int length() const { return _length; }
396 void set_length(int length) { _length = length; }
397
398 // Tells whether index is within bounds.
399 bool is_within_bounds(int index) const {
400 return 0 <= index && index < length();
401 }
402
403 static int header_size() { return sizeof(constantPoolOopDesc)/HeapWordSize; }
404 static int object_size(int length) { return align_object_size(header_size() + length); }
405 int object_size() { return object_size(length()); }
406
407 bool is_conc_safe() { return _is_conc_safe; }
408 void set_is_conc_safe(bool v) { _is_conc_safe = v; }
409
410 friend class constantPoolKlass;
411 friend class ClassFileParser;
412 friend class SystemDictionary;
413
414 // Used by compiler to prevent classloading.
415 static klassOop klass_at_if_loaded (constantPoolHandle this_oop, int which);
416 static klassOop klass_ref_at_if_loaded (constantPoolHandle this_oop, int which);
417 // Same as above - but does LinkResolving.
418 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS);
419
420 // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the
421 // future by other Java code. These take constant pool indices rather than possibly-byte-swapped
422 // constant pool cache indices as do the peer methods above.
423 symbolOop uncached_name_ref_at(int which) { return impl_name_ref_at(which, true); }
424 symbolOop uncached_signature_ref_at(int which) { return impl_signature_ref_at(which, true); }
425 int uncached_klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, true); }
426 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); }
427
428 // Sharing
429 int pre_resolve_shared_klasses(TRAPS);
430 void shared_symbols_iterate(OopClosure* closure0);
431 void shared_tags_iterate(OopClosure* closure0);
432 void shared_strings_iterate(OopClosure* closure0);
433
434 // Debugging
435 const char* printable_name_at(int which) PRODUCT_RETURN0;
436
437 private:
438
439 symbolOop impl_name_ref_at(int which, bool uncached);
440 symbolOop impl_signature_ref_at(int which, bool uncached);
441 int impl_klass_ref_index_at(int which, bool uncached);
442 int impl_name_and_type_ref_index_at(int which, bool uncached);
443
444 int remap_instruction_operand_from_cache(int operand);
445
446 // Used while constructing constant pool (only by ClassFileParser)
447 jint klass_index_at(int which) {
448 assert(tag_at(which).is_klass_index(), "Corrupted constant pool");
449 return *int_at_addr(which);
450 }
451
452 jint string_index_at(int which) {
453 assert(tag_at(which).is_string_index(), "Corrupted constant pool");
454 return *int_at_addr(which);
455 }
456
457 // Performs the LinkResolver checks
458 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS);
459
460 // Implementation of methods that needs an exposed 'this' pointer, in order to
461 // handle GC while executing the method
462 static klassOop klass_at_impl(constantPoolHandle this_oop, int which, TRAPS);
463 static oop string_at_impl(constantPoolHandle this_oop, int which, TRAPS);
464
465 // Resolve string constants (to prevent allocation during compilation)
466 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS);
467
468 public:
469 // Merging constantPoolOop support:
470 bool compare_entry_to(int index1, constantPoolHandle cp2, int index2, TRAPS);
471 void copy_cp_to(int start_i, int end_i, constantPoolHandle to_cp, int to_i,
472 TRAPS);
473 void copy_entry_to(int from_i, constantPoolHandle to_cp, int to_i, TRAPS);
474 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS);
475 int orig_length() const { return _orig_length; }
476 void set_orig_length(int orig_length) { _orig_length = orig_length; }
477
478
479 // JVMTI accesss - GetConstantPool, RetransformClasses, ...
480 friend class JvmtiConstantPoolReconstituter;
481
482 private:
483 jint cpool_entry_size(jint idx);
484 jint hash_entries_to(SymbolHashMap *symmap, SymbolHashMap *classmap);
485
486 // Copy cpool bytes into byte array.
487 // Returns:
488 // int > 0, count of the raw cpool bytes that have been copied
489 // 0, OutOfMemory error
490 // -1, Internal error
491 int copy_cpool_bytes(int cpool_size,
492 SymbolHashMap* tbl,
493 unsigned char *bytes);
494 };
495
496 class SymbolHashMapEntry : public CHeapObj {
497 private:
498 unsigned int _hash; // 32-bit hash for item
499 SymbolHashMapEntry* _next; // Next element in the linked list for this bucket
500 symbolOop _symbol; // 1-st part of the mapping: symbol => value
501 u2 _value; // 2-nd part of the mapping: symbol => value
502
503 public:
504 unsigned int hash() const { return _hash; }
505 void set_hash(unsigned int hash) { _hash = hash; }
506
507 SymbolHashMapEntry* next() const { return _next; }
508 void set_next(SymbolHashMapEntry* next) { _next = next; }
509
510 symbolOop symbol() const { return _symbol; }
511 void set_symbol(symbolOop sym) { _symbol = sym; }
512
513 u2 value() const { return _value; }
514 void set_value(u2 value) { _value = value; }
515
516 SymbolHashMapEntry(unsigned int hash, symbolOop symbol, u2 value)
517 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {}
518
519 }; // End SymbolHashMapEntry class
520
521
522 class SymbolHashMapBucket : public CHeapObj {
523
524 private:
525 SymbolHashMapEntry* _entry;
526
527 public:
528 SymbolHashMapEntry* entry() const { return _entry; }
529 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; }
530 void clear() { _entry = NULL; }
531
532 }; // End SymbolHashMapBucket class
533
534
535 class SymbolHashMap: public CHeapObj {
536
537 private:
538 // Default number of entries in the table
539 enum SymbolHashMap_Constants {
540 _Def_HashMap_Size = 256
541 };
542
543 int _table_size;
544 SymbolHashMapBucket* _buckets;
545
546 void initialize_table(int table_size) {
547 _table_size = table_size;
548 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size);
549 for (int index = 0; index < table_size; index++) {
550 _buckets[index].clear();
551 }
552 }
553
554 public:
555
556 int table_size() const { return _table_size; }
557
558 SymbolHashMap() { initialize_table(_Def_HashMap_Size); }
559 SymbolHashMap(int table_size) { initialize_table(table_size); }
560
561 // hash P(31) from Kernighan & Ritchie
562 static unsigned int compute_hash(const char* str, int len) {
563 unsigned int hash = 0;
564 while (len-- > 0) {
565 hash = 31*hash + (unsigned) *str;
566 str++;
567 }
568 return hash;
569 }
570
571 SymbolHashMapEntry* bucket(int i) {
572 return _buckets[i].entry();
573 }
574
575 void add_entry(symbolOop sym, u2 value);
576 SymbolHashMapEntry* find_entry(symbolOop sym);
577
578 u2 symbol_to_value(symbolOop sym) {
579 SymbolHashMapEntry *entry = find_entry(sym);
580 return (entry == NULL) ? 0 : entry->value();
581 }
582
583 ~SymbolHashMap() {
584 SymbolHashMapEntry* next;
585 for (int i = 0; i < _table_size; i++) {
586 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) {
587 next = cur->next();
588 delete(cur);
589 }
590 }
591 delete _buckets;
592 }
593 }; // End SymbolHashMap class