Thu, 07 Apr 2011 09:53:20 -0700
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
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 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "interpreter/linkResolver.hpp"
31 #include "memory/oopFactory.hpp"
32 #include "memory/universe.inline.hpp"
33 #include "oops/constantPoolOop.hpp"
34 #include "oops/instanceKlass.hpp"
35 #include "oops/objArrayKlass.hpp"
36 #include "oops/oop.inline.hpp"
37 #include "runtime/fieldType.hpp"
38 #include "runtime/init.hpp"
39 #include "runtime/signature.hpp"
40 #include "runtime/vframe.hpp"
42 void constantPoolOopDesc::set_flag_at(FlagBit fb) {
43 const int MAX_STATE_CHANGES = 2;
44 for (int i = MAX_STATE_CHANGES + 10; i > 0; i--) {
45 int oflags = _flags;
46 int nflags = oflags | (1 << (int)fb);
47 if (Atomic::cmpxchg(nflags, &_flags, oflags) == oflags)
48 return;
49 }
50 assert(false, "failed to cmpxchg flags");
51 _flags |= (1 << (int)fb); // better than nothing
52 }
54 klassOop constantPoolOopDesc::klass_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
55 // A resolved constantPool entry will contain a klassOop, otherwise a Symbol*.
56 // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
57 // tag is not updated atomicly.
58 CPSlot entry = this_oop->slot_at(which);
59 if (entry.is_oop()) {
60 assert(entry.get_oop()->is_klass(), "must be");
61 // Already resolved - return entry.
62 return (klassOop)entry.get_oop();
63 }
65 // Acquire lock on constant oop while doing update. After we get the lock, we check if another object
66 // already has updated the object
67 assert(THREAD->is_Java_thread(), "must be a Java thread");
68 bool do_resolve = false;
69 bool in_error = false;
71 Symbol* name = NULL;
72 Handle loader;
73 { ObjectLocker ol(this_oop, THREAD);
75 if (this_oop->tag_at(which).is_unresolved_klass()) {
76 if (this_oop->tag_at(which).is_unresolved_klass_in_error()) {
77 in_error = true;
78 } else {
79 do_resolve = true;
80 name = this_oop->unresolved_klass_at(which);
81 loader = Handle(THREAD, instanceKlass::cast(this_oop->pool_holder())->class_loader());
82 }
83 }
84 } // unlocking constantPool
87 // The original attempt to resolve this constant pool entry failed so find the
88 // original error and throw it again (JVMS 5.4.3).
89 if (in_error) {
90 Symbol* error = SystemDictionary::find_resolution_error(this_oop, which);
91 guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table");
92 ResourceMark rm;
93 // exception text will be the class name
94 const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
95 THROW_MSG_0(error, className);
96 }
98 if (do_resolve) {
99 // this_oop must be unlocked during resolve_or_fail
100 oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
101 Handle h_prot (THREAD, protection_domain);
102 klassOop k_oop = SystemDictionary::resolve_or_fail(name, loader, h_prot, true, THREAD);
103 KlassHandle k;
104 if (!HAS_PENDING_EXCEPTION) {
105 k = KlassHandle(THREAD, k_oop);
106 // Do access check for klasses
107 verify_constant_pool_resolve(this_oop, k, THREAD);
108 }
110 // Failed to resolve class. We must record the errors so that subsequent attempts
111 // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
112 if (HAS_PENDING_EXCEPTION) {
113 ResourceMark rm;
114 Symbol* error = PENDING_EXCEPTION->klass()->klass_part()->name();
116 bool throw_orig_error = false;
117 {
118 ObjectLocker ol (this_oop, THREAD);
120 // some other thread has beaten us and has resolved the class.
121 if (this_oop->tag_at(which).is_klass()) {
122 CLEAR_PENDING_EXCEPTION;
123 entry = this_oop->resolved_klass_at(which);
124 return (klassOop)entry.get_oop();
125 }
127 if (!PENDING_EXCEPTION->
128 is_a(SystemDictionary::LinkageError_klass())) {
129 // Just throw the exception and don't prevent these classes from
130 // being loaded due to virtual machine errors like StackOverflow
131 // and OutOfMemoryError, etc, or if the thread was hit by stop()
132 // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
133 }
134 else if (!this_oop->tag_at(which).is_unresolved_klass_in_error()) {
135 SystemDictionary::add_resolution_error(this_oop, which, error);
136 this_oop->tag_at_put(which, JVM_CONSTANT_UnresolvedClassInError);
137 } else {
138 // some other thread has put the class in error state.
139 error = SystemDictionary::find_resolution_error(this_oop, which);
140 assert(error != NULL, "checking");
141 throw_orig_error = true;
142 }
143 } // unlocked
145 if (throw_orig_error) {
146 CLEAR_PENDING_EXCEPTION;
147 ResourceMark rm;
148 const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
149 THROW_MSG_0(error, className);
150 }
152 return 0;
153 }
155 if (TraceClassResolution && !k()->klass_part()->oop_is_array()) {
156 // skip resolving the constant pool so that this code get's
157 // called the next time some bytecodes refer to this class.
158 ResourceMark rm;
159 int line_number = -1;
160 const char * source_file = NULL;
161 if (JavaThread::current()->has_last_Java_frame()) {
162 // try to identify the method which called this function.
163 vframeStream vfst(JavaThread::current());
164 if (!vfst.at_end()) {
165 line_number = vfst.method()->line_number_from_bci(vfst.bci());
166 Symbol* s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();
167 if (s != NULL) {
168 source_file = s->as_C_string();
169 }
170 }
171 }
172 if (k() != this_oop->pool_holder()) {
173 // only print something if the classes are different
174 if (source_file != NULL) {
175 tty->print("RESOLVE %s %s %s:%d\n",
176 instanceKlass::cast(this_oop->pool_holder())->external_name(),
177 instanceKlass::cast(k())->external_name(), source_file, line_number);
178 } else {
179 tty->print("RESOLVE %s %s\n",
180 instanceKlass::cast(this_oop->pool_holder())->external_name(),
181 instanceKlass::cast(k())->external_name());
182 }
183 }
184 return k();
185 } else {
186 ObjectLocker ol (this_oop, THREAD);
187 // Only updated constant pool - if it is resolved.
188 do_resolve = this_oop->tag_at(which).is_unresolved_klass();
189 if (do_resolve) {
190 this_oop->klass_at_put(which, k());
191 }
192 }
193 }
195 entry = this_oop->resolved_klass_at(which);
196 assert(entry.is_oop() && entry.get_oop()->is_klass(), "must be resolved at this point");
197 return (klassOop)entry.get_oop();
198 }
201 // Does not update constantPoolOop - to avoid any exception throwing. Used
202 // by compiler and exception handling. Also used to avoid classloads for
203 // instanceof operations. Returns NULL if the class has not been loaded or
204 // if the verification of constant pool failed
205 klassOop constantPoolOopDesc::klass_at_if_loaded(constantPoolHandle this_oop, int which) {
206 CPSlot entry = this_oop->slot_at(which);
207 if (entry.is_oop()) {
208 assert(entry.get_oop()->is_klass(), "must be");
209 return (klassOop)entry.get_oop();
210 } else {
211 assert(entry.is_metadata(), "must be either symbol or klass");
212 Thread *thread = Thread::current();
213 Symbol* name = entry.get_symbol();
214 oop loader = instanceKlass::cast(this_oop->pool_holder())->class_loader();
215 oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
216 Handle h_prot (thread, protection_domain);
217 Handle h_loader (thread, loader);
218 klassOop k = SystemDictionary::find(name, h_loader, h_prot, thread);
220 if (k != NULL) {
221 // Make sure that resolving is legal
222 EXCEPTION_MARK;
223 KlassHandle klass(THREAD, k);
224 // return NULL if verification fails
225 verify_constant_pool_resolve(this_oop, klass, THREAD);
226 if (HAS_PENDING_EXCEPTION) {
227 CLEAR_PENDING_EXCEPTION;
228 return NULL;
229 }
230 return klass();
231 } else {
232 return k;
233 }
234 }
235 }
238 klassOop constantPoolOopDesc::klass_ref_at_if_loaded(constantPoolHandle this_oop, int which) {
239 return klass_at_if_loaded(this_oop, this_oop->klass_ref_index_at(which));
240 }
243 // This is an interface for the compiler that allows accessing non-resolved entries
244 // in the constant pool - but still performs the validations tests. Must be used
245 // in a pre-parse of the compiler - to determine what it can do and not do.
246 // Note: We cannot update the ConstantPool from the vm_thread.
247 klassOop constantPoolOopDesc::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {
248 int which = this_oop->klass_ref_index_at(index);
249 CPSlot entry = this_oop->slot_at(which);
250 if (entry.is_oop()) {
251 assert(entry.get_oop()->is_klass(), "must be");
252 return (klassOop)entry.get_oop();
253 } else {
254 assert(entry.is_metadata(), "must be either symbol or klass");
255 Symbol* name = entry.get_symbol();
256 oop loader = instanceKlass::cast(this_oop->pool_holder())->class_loader();
257 oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
258 Handle h_loader(THREAD, loader);
259 Handle h_prot (THREAD, protection_domain);
260 KlassHandle k(THREAD, SystemDictionary::find(name, h_loader, h_prot, THREAD));
262 // Do access check for klasses
263 if( k.not_null() ) verify_constant_pool_resolve(this_oop, k, CHECK_NULL);
264 return k();
265 }
266 }
269 Symbol* constantPoolOopDesc::impl_name_ref_at(int which, bool uncached) {
270 int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
271 return symbol_at(name_index);
272 }
275 Symbol* constantPoolOopDesc::impl_signature_ref_at(int which, bool uncached) {
276 int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
277 return symbol_at(signature_index);
278 }
281 int constantPoolOopDesc::impl_name_and_type_ref_index_at(int which, bool uncached) {
282 int i = which;
283 if (!uncached && cache() != NULL) {
284 if (constantPoolCacheOopDesc::is_secondary_index(which)) {
285 // Invokedynamic index.
286 int pool_index = cache()->main_entry_at(which)->constant_pool_index();
287 if (!AllowTransitionalJSR292 || tag_at(pool_index).is_invoke_dynamic())
288 pool_index = invoke_dynamic_name_and_type_ref_index_at(pool_index);
289 assert(tag_at(pool_index).is_name_and_type(), "");
290 return pool_index;
291 }
292 // change byte-ordering and go via cache
293 i = remap_instruction_operand_from_cache(which);
294 } else {
295 if (AllowTransitionalJSR292 && tag_at(which).is_name_and_type())
296 // invokedynamic index is a simple name-and-type
297 return which;
298 if (tag_at(which).is_invoke_dynamic()) {
299 int pool_index = invoke_dynamic_name_and_type_ref_index_at(which);
300 assert(tag_at(pool_index).is_name_and_type(), "");
301 return pool_index;
302 }
303 }
304 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
305 assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");
306 jint ref_index = *int_at_addr(i);
307 return extract_high_short_from_int(ref_index);
308 }
311 int constantPoolOopDesc::impl_klass_ref_index_at(int which, bool uncached) {
312 guarantee(!constantPoolCacheOopDesc::is_secondary_index(which),
313 "an invokedynamic instruction does not have a klass");
314 int i = which;
315 if (!uncached && cache() != NULL) {
316 // change byte-ordering and go via cache
317 i = remap_instruction_operand_from_cache(which);
318 }
319 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
320 jint ref_index = *int_at_addr(i);
321 return extract_low_short_from_int(ref_index);
322 }
326 int constantPoolOopDesc::remap_instruction_operand_from_cache(int operand) {
327 int cpc_index = operand;
328 DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
329 assert((int)(u2)cpc_index == cpc_index, "clean u2");
330 int member_index = cache()->entry_at(cpc_index)->constant_pool_index();
331 return member_index;
332 }
335 void constantPoolOopDesc::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
336 if (k->oop_is_instance() || k->oop_is_objArray()) {
337 instanceKlassHandle holder (THREAD, this_oop->pool_holder());
338 klassOop elem_oop = k->oop_is_instance() ? k() : objArrayKlass::cast(k())->bottom_klass();
339 KlassHandle element (THREAD, elem_oop);
341 // The element type could be a typeArray - we only need the access check if it is
342 // an reference to another class
343 if (element->oop_is_instance()) {
344 LinkResolver::check_klass_accessability(holder, element, CHECK);
345 }
346 }
347 }
350 int constantPoolOopDesc::name_ref_index_at(int which_nt) {
351 jint ref_index = name_and_type_at(which_nt);
352 return extract_low_short_from_int(ref_index);
353 }
356 int constantPoolOopDesc::signature_ref_index_at(int which_nt) {
357 jint ref_index = name_and_type_at(which_nt);
358 return extract_high_short_from_int(ref_index);
359 }
362 klassOop constantPoolOopDesc::klass_ref_at(int which, TRAPS) {
363 return klass_at(klass_ref_index_at(which), CHECK_NULL);
364 }
367 Symbol* constantPoolOopDesc::klass_name_at(int which) {
368 assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),
369 "Corrupted constant pool");
370 // A resolved constantPool entry will contain a klassOop, otherwise a Symbol*.
371 // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
372 // tag is not updated atomicly.
373 CPSlot entry = slot_at(which);
374 if (entry.is_oop()) {
375 // Already resolved - return entry's name.
376 assert(entry.get_oop()->is_klass(), "must be");
377 return klassOop(entry.get_oop())->klass_part()->name();
378 } else {
379 assert(entry.is_metadata(), "must be either symbol or klass");
380 return entry.get_symbol();
381 }
382 }
384 Symbol* constantPoolOopDesc::klass_ref_at_noresolve(int which) {
385 jint ref_index = klass_ref_index_at(which);
386 return klass_at_noresolve(ref_index);
387 }
389 Symbol* constantPoolOopDesc::uncached_klass_ref_at_noresolve(int which) {
390 jint ref_index = uncached_klass_ref_index_at(which);
391 return klass_at_noresolve(ref_index);
392 }
394 char* constantPoolOopDesc::string_at_noresolve(int which) {
395 // Test entry type in case string is resolved while in here.
396 CPSlot entry = slot_at(which);
397 if (entry.is_metadata()) {
398 return (entry.get_symbol())->as_C_string();
399 } else if (java_lang_String::is_instance(entry.get_oop())) {
400 return java_lang_String::as_utf8_string(entry.get_oop());
401 } else {
402 return (char*)"<pseudo-string>";
403 }
404 }
407 BasicType constantPoolOopDesc::basic_type_for_signature_at(int which) {
408 return FieldType::basic_type(symbol_at(which));
409 }
412 void constantPoolOopDesc::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
413 for (int index = 1; index < this_oop->length(); index++) { // Index 0 is unused
414 if (this_oop->tag_at(index).is_unresolved_string()) {
415 this_oop->string_at(index, CHECK);
416 }
417 }
418 }
420 // A resolved constant value in the CP cache is represented as a non-null
421 // value. As a special case, this value can be a 'systemObjArray'
422 // which masks an exception object to throw.
423 // This allows a MethodHandle constant reference to throw a consistent
424 // exception every time, if it fails to resolve.
425 static oop decode_exception_from_f1(oop result_oop, TRAPS) {
426 if (result_oop->klass() != Universe::systemObjArrayKlassObj())
427 return result_oop;
429 // Special cases here: Masked null, saved exception.
430 objArrayOop sys_array = (objArrayOop) result_oop;
431 assert(sys_array->length() == 1, "bad system array");
432 if (sys_array->length() == 1) {
433 THROW_OOP_(sys_array->obj_at(0), NULL);
434 }
435 return NULL;
436 }
438 oop constantPoolOopDesc::resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS) {
439 oop result_oop = NULL;
440 Handle throw_exception;
442 if (cache_index == _possible_index_sentinel) {
443 // It is possible that this constant is one which is cached in the CP cache.
444 // We'll do a linear search. This should be OK because this usage is rare.
445 assert(index > 0, "valid index");
446 constantPoolCacheOop cache = this_oop()->cache();
447 for (int i = 0, len = cache->length(); i < len; i++) {
448 ConstantPoolCacheEntry* cpc_entry = cache->entry_at(i);
449 if (!cpc_entry->is_secondary_entry() && cpc_entry->constant_pool_index() == index) {
450 // Switch the query to use this CPC entry.
451 cache_index = i;
452 index = _no_index_sentinel;
453 break;
454 }
455 }
456 if (cache_index == _possible_index_sentinel)
457 cache_index = _no_index_sentinel; // not found
458 }
459 assert(cache_index == _no_index_sentinel || cache_index >= 0, "");
460 assert(index == _no_index_sentinel || index >= 0, "");
462 if (cache_index >= 0) {
463 assert(index == _no_index_sentinel, "only one kind of index at a time");
464 ConstantPoolCacheEntry* cpc_entry = this_oop->cache()->entry_at(cache_index);
465 result_oop = cpc_entry->f1();
466 if (result_oop != NULL) {
467 return decode_exception_from_f1(result_oop, THREAD);
468 // That was easy...
469 }
470 index = cpc_entry->constant_pool_index();
471 }
473 jvalue prim_value; // temp used only in a few cases below
475 int tag_value = this_oop->tag_at(index).value();
476 switch (tag_value) {
478 case JVM_CONSTANT_UnresolvedClass:
479 case JVM_CONSTANT_UnresolvedClassInError:
480 case JVM_CONSTANT_Class:
481 {
482 klassOop resolved = klass_at_impl(this_oop, index, CHECK_NULL);
483 // ldc wants the java mirror.
484 result_oop = resolved->java_mirror();
485 break;
486 }
488 case JVM_CONSTANT_String:
489 case JVM_CONSTANT_UnresolvedString:
490 if (this_oop->is_pseudo_string_at(index)) {
491 result_oop = this_oop->pseudo_string_at(index);
492 break;
493 }
494 result_oop = string_at_impl(this_oop, index, CHECK_NULL);
495 break;
497 case JVM_CONSTANT_Object:
498 result_oop = this_oop->object_at(index);
499 break;
501 case JVM_CONSTANT_MethodHandle:
502 {
503 int ref_kind = this_oop->method_handle_ref_kind_at(index);
504 int callee_index = this_oop->method_handle_klass_index_at(index);
505 Symbol* name = this_oop->method_handle_name_ref_at(index);
506 Symbol* signature = this_oop->method_handle_signature_ref_at(index);
507 if (PrintMiscellaneous)
508 tty->print_cr("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",
509 ref_kind, index, this_oop->method_handle_index_at(index),
510 callee_index, name->as_C_string(), signature->as_C_string());
511 KlassHandle callee;
512 { klassOop k = klass_at_impl(this_oop, callee_index, CHECK_NULL);
513 callee = KlassHandle(THREAD, k);
514 }
515 KlassHandle klass(THREAD, this_oop->pool_holder());
516 Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,
517 callee, name, signature,
518 THREAD);
519 if (HAS_PENDING_EXCEPTION) {
520 throw_exception = Handle(THREAD, PENDING_EXCEPTION);
521 CLEAR_PENDING_EXCEPTION;
522 break;
523 }
524 result_oop = value();
525 assert(result_oop != NULL, "");
526 break;
527 }
529 case JVM_CONSTANT_MethodType:
530 {
531 Symbol* signature = this_oop->method_type_signature_at(index);
532 if (PrintMiscellaneous)
533 tty->print_cr("resolve JVM_CONSTANT_MethodType [%d/%d] %s",
534 index, this_oop->method_type_index_at(index),
535 signature->as_C_string());
536 KlassHandle klass(THREAD, this_oop->pool_holder());
537 bool ignore_is_on_bcp = false;
538 Handle value = SystemDictionary::find_method_handle_type(signature,
539 klass,
540 false,
541 ignore_is_on_bcp,
542 THREAD);
543 if (HAS_PENDING_EXCEPTION) {
544 throw_exception = Handle(THREAD, PENDING_EXCEPTION);
545 CLEAR_PENDING_EXCEPTION;
546 break;
547 }
548 result_oop = value();
549 assert(result_oop != NULL, "");
550 break;
551 }
553 case JVM_CONSTANT_Integer:
554 prim_value.i = this_oop->int_at(index);
555 result_oop = java_lang_boxing_object::create(T_INT, &prim_value, CHECK_NULL);
556 break;
558 case JVM_CONSTANT_Float:
559 prim_value.f = this_oop->float_at(index);
560 result_oop = java_lang_boxing_object::create(T_FLOAT, &prim_value, CHECK_NULL);
561 break;
563 case JVM_CONSTANT_Long:
564 prim_value.j = this_oop->long_at(index);
565 result_oop = java_lang_boxing_object::create(T_LONG, &prim_value, CHECK_NULL);
566 break;
568 case JVM_CONSTANT_Double:
569 prim_value.d = this_oop->double_at(index);
570 result_oop = java_lang_boxing_object::create(T_DOUBLE, &prim_value, CHECK_NULL);
571 break;
573 default:
574 DEBUG_ONLY( tty->print_cr("*** %p: tag at CP[%d/%d] = %d",
575 this_oop(), index, cache_index, tag_value) );
576 assert(false, "unexpected constant tag");
577 break;
578 }
580 if (cache_index >= 0) {
581 // Cache the oop here also.
582 if (throw_exception.not_null()) {
583 objArrayOop sys_array = oopFactory::new_system_objArray(1, CHECK_NULL);
584 sys_array->obj_at_put(0, throw_exception());
585 result_oop = sys_array;
586 throw_exception = Handle(); // be tidy
587 }
588 Handle result_handle(THREAD, result_oop);
589 result_oop = NULL; // safety
590 ObjectLocker ol(this_oop, THREAD);
591 ConstantPoolCacheEntry* cpc_entry = this_oop->cache()->entry_at(cache_index);
592 result_oop = cpc_entry->f1();
593 // Benign race condition: f1 may already be filled in while we were trying to lock.
594 // The important thing here is that all threads pick up the same result.
595 // It doesn't matter which racing thread wins, as long as only one
596 // result is used by all threads, and all future queries.
597 // That result may be either a resolved constant or a failure exception.
598 if (result_oop == NULL) {
599 result_oop = result_handle();
600 cpc_entry->set_f1(result_oop);
601 }
602 return decode_exception_from_f1(result_oop, THREAD);
603 } else {
604 if (throw_exception.not_null()) {
605 THROW_HANDLE_(throw_exception, NULL);
606 }
607 return result_oop;
608 }
609 }
611 oop constantPoolOopDesc::string_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
612 oop str = NULL;
613 CPSlot entry = this_oop->slot_at(which);
614 if (entry.is_metadata()) {
615 ObjectLocker ol(this_oop, THREAD);
616 if (this_oop->tag_at(which).is_unresolved_string()) {
617 // Intern string
618 Symbol* sym = this_oop->unresolved_string_at(which);
619 str = StringTable::intern(sym, CHECK_(constantPoolOop(NULL)));
620 this_oop->string_at_put(which, str);
621 } else {
622 // Another thread beat us and interned string, read string from constant pool
623 str = this_oop->resolved_string_at(which);
624 }
625 } else {
626 str = entry.get_oop();
627 }
628 assert(java_lang_String::is_instance(str), "must be string");
629 return str;
630 }
633 bool constantPoolOopDesc::is_pseudo_string_at(int which) {
634 CPSlot entry = slot_at(which);
635 if (entry.is_metadata())
636 // Not yet resolved, but it will resolve to a string.
637 return false;
638 else if (java_lang_String::is_instance(entry.get_oop()))
639 return false; // actually, it might be a non-interned or non-perm string
640 else
641 // truly pseudo
642 return true;
643 }
646 bool constantPoolOopDesc::klass_name_at_matches(instanceKlassHandle k,
647 int which) {
648 // Names are interned, so we can compare Symbol*s directly
649 Symbol* cp_name = klass_name_at(which);
650 return (cp_name == k->name());
651 }
654 int constantPoolOopDesc::pre_resolve_shared_klasses(TRAPS) {
655 ResourceMark rm;
656 int count = 0;
657 for (int index = 1; index < tags()->length(); index++) { // Index 0 is unused
658 if (tag_at(index).is_unresolved_string()) {
659 // Intern string
660 Symbol* sym = unresolved_string_at(index);
661 oop entry = StringTable::intern(sym, CHECK_(-1));
662 string_at_put(index, entry);
663 }
664 }
665 return count;
666 }
668 // Iterate over symbols and decrement ones which are Symbol*s.
669 // This is done during GC so do not need to lock constantPool unless we
670 // have per-thread safepoints.
671 // Only decrement the UTF8 symbols. Unresolved classes and strings point to
672 // these symbols but didn't increment the reference count.
673 void constantPoolOopDesc::unreference_symbols() {
674 for (int index = 1; index < length(); index++) { // Index 0 is unused
675 constantTag tag = tag_at(index);
676 if (tag.is_symbol()) {
677 symbol_at(index)->decrement_refcount();
678 }
679 }
680 }
682 // Iterate over symbols which are used as class, field, method names and
683 // signatures (in preparation for writing to the shared archive).
685 void constantPoolOopDesc::shared_symbols_iterate(SymbolClosure* closure) {
686 for (int index = 1; index < length(); index++) { // Index 0 is unused
687 switch (tag_at(index).value()) {
689 case JVM_CONSTANT_UnresolvedClass:
690 case JVM_CONSTANT_UnresolvedString:
691 case JVM_CONSTANT_Utf8:
692 assert(slot_at(index).is_metadata(), "must be symbol");
693 closure->do_symbol(symbol_at_addr(index));
694 break;
696 case JVM_CONSTANT_NameAndType:
697 {
698 int i = *int_at_addr(index);
699 closure->do_symbol(symbol_at_addr((unsigned)i >> 16));
700 closure->do_symbol(symbol_at_addr((unsigned)i & 0xffff));
701 }
702 break;
704 case JVM_CONSTANT_Class:
705 case JVM_CONSTANT_InterfaceMethodref:
706 case JVM_CONSTANT_Fieldref:
707 case JVM_CONSTANT_Methodref:
708 case JVM_CONSTANT_Integer:
709 case JVM_CONSTANT_Float:
710 // Do nothing! Not an oop.
711 // These constant types do not reference symbols at this point.
712 break;
714 case JVM_CONSTANT_String:
715 // Do nothing! Not a symbol.
716 break;
718 case JVM_CONSTANT_Long:
719 case JVM_CONSTANT_Double:
720 // Do nothing! Not an oop. (But takes two pool entries.)
721 ++index;
722 break;
724 default:
725 ShouldNotReachHere();
726 break;
727 }
728 }
729 }
732 // Iterate over the [one] tags array (in preparation for writing to the
733 // shared archive).
735 void constantPoolOopDesc::shared_tags_iterate(OopClosure* closure) {
736 closure->do_oop(tags_addr());
737 closure->do_oop(operands_addr());
738 }
741 // Iterate over String objects (in preparation for writing to the shared
742 // archive).
744 void constantPoolOopDesc::shared_strings_iterate(OopClosure* closure) {
745 for (int index = 1; index < length(); index++) { // Index 0 is unused
746 switch (tag_at(index).value()) {
748 case JVM_CONSTANT_UnresolvedClass:
749 case JVM_CONSTANT_NameAndType:
750 // Do nothing! Not a String.
751 break;
753 case JVM_CONSTANT_Class:
754 case JVM_CONSTANT_InterfaceMethodref:
755 case JVM_CONSTANT_Fieldref:
756 case JVM_CONSTANT_Methodref:
757 case JVM_CONSTANT_Integer:
758 case JVM_CONSTANT_Float:
759 // Do nothing! Not an oop.
760 // These constant types do not reference symbols at this point.
761 break;
763 case JVM_CONSTANT_String:
764 closure->do_oop(obj_at_addr_raw(index));
765 break;
767 case JVM_CONSTANT_UnresolvedString:
768 case JVM_CONSTANT_Utf8:
769 // These constants are symbols, but unless these symbols are
770 // actually to be used for something, we don't want to mark them.
771 break;
773 case JVM_CONSTANT_Long:
774 case JVM_CONSTANT_Double:
775 // Do nothing! Not an oop. (But takes two pool entries.)
776 ++index;
777 break;
779 default:
780 ShouldNotReachHere();
781 break;
782 }
783 }
784 }
787 // Compare this constant pool's entry at index1 to the constant pool
788 // cp2's entry at index2.
789 bool constantPoolOopDesc::compare_entry_to(int index1, constantPoolHandle cp2,
790 int index2, TRAPS) {
792 jbyte t1 = tag_at(index1).value();
793 jbyte t2 = cp2->tag_at(index2).value();
796 // JVM_CONSTANT_UnresolvedClassInError is equal to JVM_CONSTANT_UnresolvedClass
797 // when comparing
798 if (t1 == JVM_CONSTANT_UnresolvedClassInError) {
799 t1 = JVM_CONSTANT_UnresolvedClass;
800 }
801 if (t2 == JVM_CONSTANT_UnresolvedClassInError) {
802 t2 = JVM_CONSTANT_UnresolvedClass;
803 }
805 if (t1 != t2) {
806 // Not the same entry type so there is nothing else to check. Note
807 // that this style of checking will consider resolved/unresolved
808 // class pairs and resolved/unresolved string pairs as different.
809 // From the constantPoolOop API point of view, this is correct
810 // behavior. See constantPoolKlass::merge() to see how this plays
811 // out in the context of constantPoolOop merging.
812 return false;
813 }
815 switch (t1) {
816 case JVM_CONSTANT_Class:
817 {
818 klassOop k1 = klass_at(index1, CHECK_false);
819 klassOop k2 = cp2->klass_at(index2, CHECK_false);
820 if (k1 == k2) {
821 return true;
822 }
823 } break;
825 case JVM_CONSTANT_ClassIndex:
826 {
827 int recur1 = klass_index_at(index1);
828 int recur2 = cp2->klass_index_at(index2);
829 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
830 if (match) {
831 return true;
832 }
833 } break;
835 case JVM_CONSTANT_Double:
836 {
837 jdouble d1 = double_at(index1);
838 jdouble d2 = cp2->double_at(index2);
839 if (d1 == d2) {
840 return true;
841 }
842 } break;
844 case JVM_CONSTANT_Fieldref:
845 case JVM_CONSTANT_InterfaceMethodref:
846 case JVM_CONSTANT_Methodref:
847 {
848 int recur1 = uncached_klass_ref_index_at(index1);
849 int recur2 = cp2->uncached_klass_ref_index_at(index2);
850 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
851 if (match) {
852 recur1 = uncached_name_and_type_ref_index_at(index1);
853 recur2 = cp2->uncached_name_and_type_ref_index_at(index2);
854 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
855 if (match) {
856 return true;
857 }
858 }
859 } break;
861 case JVM_CONSTANT_Float:
862 {
863 jfloat f1 = float_at(index1);
864 jfloat f2 = cp2->float_at(index2);
865 if (f1 == f2) {
866 return true;
867 }
868 } break;
870 case JVM_CONSTANT_Integer:
871 {
872 jint i1 = int_at(index1);
873 jint i2 = cp2->int_at(index2);
874 if (i1 == i2) {
875 return true;
876 }
877 } break;
879 case JVM_CONSTANT_Long:
880 {
881 jlong l1 = long_at(index1);
882 jlong l2 = cp2->long_at(index2);
883 if (l1 == l2) {
884 return true;
885 }
886 } break;
888 case JVM_CONSTANT_NameAndType:
889 {
890 int recur1 = name_ref_index_at(index1);
891 int recur2 = cp2->name_ref_index_at(index2);
892 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
893 if (match) {
894 recur1 = signature_ref_index_at(index1);
895 recur2 = cp2->signature_ref_index_at(index2);
896 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
897 if (match) {
898 return true;
899 }
900 }
901 } break;
903 case JVM_CONSTANT_String:
904 {
905 oop s1 = string_at(index1, CHECK_false);
906 oop s2 = cp2->string_at(index2, CHECK_false);
907 if (s1 == s2) {
908 return true;
909 }
910 } break;
912 case JVM_CONSTANT_StringIndex:
913 {
914 int recur1 = string_index_at(index1);
915 int recur2 = cp2->string_index_at(index2);
916 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
917 if (match) {
918 return true;
919 }
920 } break;
922 case JVM_CONSTANT_UnresolvedClass:
923 {
924 Symbol* k1 = unresolved_klass_at(index1);
925 Symbol* k2 = cp2->unresolved_klass_at(index2);
926 if (k1 == k2) {
927 return true;
928 }
929 } break;
931 case JVM_CONSTANT_MethodType:
932 {
933 int k1 = method_type_index_at(index1);
934 int k2 = cp2->method_type_index_at(index2);
935 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
936 if (match) {
937 return true;
938 }
939 } break;
941 case JVM_CONSTANT_MethodHandle:
942 {
943 int k1 = method_handle_ref_kind_at(index1);
944 int k2 = cp2->method_handle_ref_kind_at(index2);
945 if (k1 == k2) {
946 int i1 = method_handle_index_at(index1);
947 int i2 = cp2->method_handle_index_at(index2);
948 bool match = compare_entry_to(i1, cp2, i2, CHECK_false);
949 if (match) {
950 return true;
951 }
952 }
953 } break;
955 case JVM_CONSTANT_InvokeDynamic:
956 case JVM_CONSTANT_InvokeDynamicTrans:
957 {
958 int k1 = invoke_dynamic_bootstrap_method_ref_index_at(index1);
959 int k2 = cp2->invoke_dynamic_bootstrap_method_ref_index_at(index2);
960 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
961 if (!match) return false;
962 k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
963 k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
964 match = compare_entry_to(k1, cp2, k2, CHECK_false);
965 if (!match) return false;
966 int argc = invoke_dynamic_argument_count_at(index1);
967 if (argc == cp2->invoke_dynamic_argument_count_at(index2)) {
968 for (int j = 0; j < argc; j++) {
969 k1 = invoke_dynamic_argument_index_at(index1, j);
970 k2 = cp2->invoke_dynamic_argument_index_at(index2, j);
971 match = compare_entry_to(k1, cp2, k2, CHECK_false);
972 if (!match) return false;
973 }
974 return true; // got through loop; all elements equal
975 }
976 } break;
978 case JVM_CONSTANT_UnresolvedString:
979 {
980 Symbol* s1 = unresolved_string_at(index1);
981 Symbol* s2 = cp2->unresolved_string_at(index2);
982 if (s1 == s2) {
983 return true;
984 }
985 } break;
987 case JVM_CONSTANT_Utf8:
988 {
989 Symbol* s1 = symbol_at(index1);
990 Symbol* s2 = cp2->symbol_at(index2);
991 if (s1 == s2) {
992 return true;
993 }
994 } break;
996 // Invalid is used as the tag for the second constant pool entry
997 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
998 // not be seen by itself.
999 case JVM_CONSTANT_Invalid: // fall through
1001 default:
1002 ShouldNotReachHere();
1003 break;
1004 }
1006 return false;
1007 } // end compare_entry_to()
1010 // Copy this constant pool's entries at start_i to end_i (inclusive)
1011 // to the constant pool to_cp's entries starting at to_i. A total of
1012 // (end_i - start_i) + 1 entries are copied.
1013 void constantPoolOopDesc::copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i,
1014 constantPoolHandle to_cp, int to_i, TRAPS) {
1016 int dest_i = to_i; // leave original alone for debug purposes
1018 for (int src_i = start_i; src_i <= end_i; /* see loop bottom */ ) {
1019 copy_entry_to(from_cp, src_i, to_cp, dest_i, CHECK);
1021 switch (from_cp->tag_at(src_i).value()) {
1022 case JVM_CONSTANT_Double:
1023 case JVM_CONSTANT_Long:
1024 // double and long take two constant pool entries
1025 src_i += 2;
1026 dest_i += 2;
1027 break;
1029 default:
1030 // all others take one constant pool entry
1031 src_i++;
1032 dest_i++;
1033 break;
1034 }
1035 }
1037 int from_oplen = operand_array_length(from_cp->operands());
1038 int old_oplen = operand_array_length(to_cp->operands());
1039 if (from_oplen != 0) {
1040 // append my operands to the target's operands array
1041 if (old_oplen == 0) {
1042 to_cp->set_operands(from_cp->operands()); // reuse; do not merge
1043 } else {
1044 int old_len = to_cp->operands()->length();
1045 int from_len = from_cp->operands()->length();
1046 int old_off = old_oplen * sizeof(u2);
1047 int from_off = from_oplen * sizeof(u2);
1048 typeArrayHandle new_operands = oopFactory::new_permanent_shortArray(old_len + from_len, CHECK);
1049 int fillp = 0, len = 0;
1050 // first part of dest
1051 Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(0),
1052 new_operands->short_at_addr(fillp),
1053 (len = old_off) * sizeof(u2));
1054 fillp += len;
1055 // first part of src
1056 Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(0),
1057 new_operands->short_at_addr(fillp),
1058 (len = from_off) * sizeof(u2));
1059 fillp += len;
1060 // second part of dest
1061 Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(old_off),
1062 new_operands->short_at_addr(fillp),
1063 (len = old_len - old_off) * sizeof(u2));
1064 fillp += len;
1065 // second part of src
1066 Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(from_off),
1067 new_operands->short_at_addr(fillp),
1068 (len = from_len - from_off) * sizeof(u2));
1069 fillp += len;
1070 assert(fillp == new_operands->length(), "");
1072 // Adjust indexes in the first part of the copied operands array.
1073 for (int j = 0; j < from_oplen; j++) {
1074 int offset = operand_offset_at(new_operands(), old_oplen + j);
1075 assert(offset == operand_offset_at(from_cp->operands(), j), "correct copy");
1076 offset += old_len; // every new tuple is preceded by old_len extra u2's
1077 operand_offset_at_put(new_operands(), old_oplen + j, offset);
1078 }
1080 // replace target operands array with combined array
1081 to_cp->set_operands(new_operands());
1082 }
1083 }
1085 } // end copy_cp_to()
1088 // Copy this constant pool's entry at from_i to the constant pool
1089 // to_cp's entry at to_i.
1090 void constantPoolOopDesc::copy_entry_to(constantPoolHandle from_cp, int from_i,
1091 constantPoolHandle to_cp, int to_i,
1092 TRAPS) {
1094 int tag = from_cp->tag_at(from_i).value();
1095 switch (tag) {
1096 case JVM_CONSTANT_Class:
1097 {
1098 klassOop k = from_cp->klass_at(from_i, CHECK);
1099 to_cp->klass_at_put(to_i, k);
1100 } break;
1102 case JVM_CONSTANT_ClassIndex:
1103 {
1104 jint ki = from_cp->klass_index_at(from_i);
1105 to_cp->klass_index_at_put(to_i, ki);
1106 } break;
1108 case JVM_CONSTANT_Double:
1109 {
1110 jdouble d = from_cp->double_at(from_i);
1111 to_cp->double_at_put(to_i, d);
1112 // double takes two constant pool entries so init second entry's tag
1113 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
1114 } break;
1116 case JVM_CONSTANT_Fieldref:
1117 {
1118 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1119 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1120 to_cp->field_at_put(to_i, class_index, name_and_type_index);
1121 } break;
1123 case JVM_CONSTANT_Float:
1124 {
1125 jfloat f = from_cp->float_at(from_i);
1126 to_cp->float_at_put(to_i, f);
1127 } break;
1129 case JVM_CONSTANT_Integer:
1130 {
1131 jint i = from_cp->int_at(from_i);
1132 to_cp->int_at_put(to_i, i);
1133 } break;
1135 case JVM_CONSTANT_InterfaceMethodref:
1136 {
1137 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1138 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1139 to_cp->interface_method_at_put(to_i, class_index, name_and_type_index);
1140 } break;
1142 case JVM_CONSTANT_Long:
1143 {
1144 jlong l = from_cp->long_at(from_i);
1145 to_cp->long_at_put(to_i, l);
1146 // long takes two constant pool entries so init second entry's tag
1147 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
1148 } break;
1150 case JVM_CONSTANT_Methodref:
1151 {
1152 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1153 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1154 to_cp->method_at_put(to_i, class_index, name_and_type_index);
1155 } break;
1157 case JVM_CONSTANT_NameAndType:
1158 {
1159 int name_ref_index = from_cp->name_ref_index_at(from_i);
1160 int signature_ref_index = from_cp->signature_ref_index_at(from_i);
1161 to_cp->name_and_type_at_put(to_i, name_ref_index, signature_ref_index);
1162 } break;
1164 case JVM_CONSTANT_String:
1165 {
1166 oop s = from_cp->string_at(from_i, CHECK);
1167 to_cp->string_at_put(to_i, s);
1168 } break;
1170 case JVM_CONSTANT_StringIndex:
1171 {
1172 jint si = from_cp->string_index_at(from_i);
1173 to_cp->string_index_at_put(to_i, si);
1174 } break;
1176 case JVM_CONSTANT_UnresolvedClass:
1177 {
1178 // Can be resolved after checking tag, so check the slot first.
1179 CPSlot entry = from_cp->slot_at(from_i);
1180 if (entry.is_oop()) {
1181 assert(entry.get_oop()->is_klass(), "must be");
1182 // Already resolved
1183 to_cp->klass_at_put(to_i, (klassOop)entry.get_oop());
1184 } else {
1185 to_cp->unresolved_klass_at_put(to_i, entry.get_symbol());
1186 }
1187 } break;
1189 case JVM_CONSTANT_UnresolvedClassInError:
1190 {
1191 Symbol* k = from_cp->unresolved_klass_at(from_i);
1192 to_cp->unresolved_klass_at_put(to_i, k);
1193 to_cp->tag_at_put(to_i, JVM_CONSTANT_UnresolvedClassInError);
1194 } break;
1197 case JVM_CONSTANT_UnresolvedString:
1198 {
1199 // Can be resolved after checking tag, so check the slot first.
1200 CPSlot entry = from_cp->slot_at(from_i);
1201 if (entry.is_oop()) {
1202 // Already resolved (either string or pseudo-string)
1203 to_cp->string_at_put(to_i, entry.get_oop());
1204 } else {
1205 to_cp->unresolved_string_at_put(to_i, entry.get_symbol());
1206 }
1207 } break;
1209 case JVM_CONSTANT_Utf8:
1210 {
1211 Symbol* s = from_cp->symbol_at(from_i);
1212 to_cp->symbol_at_put(to_i, s);
1213 // This constantPool has the same lifetime as the original, so don't
1214 // increase reference counts for the copy.
1215 } break;
1217 case JVM_CONSTANT_MethodType:
1218 {
1219 jint k = from_cp->method_type_index_at(from_i);
1220 to_cp->method_type_index_at_put(to_i, k);
1221 } break;
1223 case JVM_CONSTANT_MethodHandle:
1224 {
1225 int k1 = from_cp->method_handle_ref_kind_at(from_i);
1226 int k2 = from_cp->method_handle_index_at(from_i);
1227 to_cp->method_handle_index_at_put(to_i, k1, k2);
1228 } break;
1230 case JVM_CONSTANT_InvokeDynamicTrans:
1231 {
1232 int k1 = from_cp->invoke_dynamic_bootstrap_method_ref_index_at(from_i);
1233 int k2 = from_cp->invoke_dynamic_name_and_type_ref_index_at(from_i);
1234 to_cp->invoke_dynamic_trans_at_put(to_i, k1, k2);
1235 } break;
1237 case JVM_CONSTANT_InvokeDynamic:
1238 {
1239 int k1 = from_cp->invoke_dynamic_bootstrap_specifier_index(from_i);
1240 int k2 = from_cp->invoke_dynamic_name_and_type_ref_index_at(from_i);
1241 k1 += operand_array_length(to_cp->operands()); // to_cp might already have operands
1242 to_cp->invoke_dynamic_at_put(to_i, k1, k2);
1243 } break;
1245 // Invalid is used as the tag for the second constant pool entry
1246 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
1247 // not be seen by itself.
1248 case JVM_CONSTANT_Invalid: // fall through
1250 default:
1251 {
1252 ShouldNotReachHere();
1253 } break;
1254 }
1255 } // end copy_entry_to()
1258 // Search constant pool search_cp for an entry that matches this
1259 // constant pool's entry at pattern_i. Returns the index of a
1260 // matching entry or zero (0) if there is no matching entry.
1261 int constantPoolOopDesc::find_matching_entry(int pattern_i,
1262 constantPoolHandle search_cp, TRAPS) {
1264 // index zero (0) is not used
1265 for (int i = 1; i < search_cp->length(); i++) {
1266 bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
1267 if (found) {
1268 return i;
1269 }
1270 }
1272 return 0; // entry not found; return unused index zero (0)
1273 } // end find_matching_entry()
1276 #ifndef PRODUCT
1278 const char* constantPoolOopDesc::printable_name_at(int which) {
1280 constantTag tag = tag_at(which);
1282 if (tag.is_unresolved_string() || tag.is_string()) {
1283 return string_at_noresolve(which);
1284 } else if (tag.is_klass() || tag.is_unresolved_klass()) {
1285 return klass_name_at(which)->as_C_string();
1286 } else if (tag.is_symbol()) {
1287 return symbol_at(which)->as_C_string();
1288 }
1289 return "";
1290 }
1292 #endif // PRODUCT
1295 // JVMTI GetConstantPool support
1297 // For temporary use until code is stable.
1298 #define DBG(code)
1300 static const char* WARN_MSG = "Must not be such entry!";
1302 static void print_cpool_bytes(jint cnt, u1 *bytes) {
1303 jint size = 0;
1304 u2 idx1, idx2;
1306 for (jint idx = 1; idx < cnt; idx++) {
1307 jint ent_size = 0;
1308 u1 tag = *bytes++;
1309 size++; // count tag
1311 printf("const #%03d, tag: %02d ", idx, tag);
1312 switch(tag) {
1313 case JVM_CONSTANT_Invalid: {
1314 printf("Invalid");
1315 break;
1316 }
1317 case JVM_CONSTANT_Unicode: {
1318 printf("Unicode %s", WARN_MSG);
1319 break;
1320 }
1321 case JVM_CONSTANT_Utf8: {
1322 u2 len = Bytes::get_Java_u2(bytes);
1323 char str[128];
1324 if (len > 127) {
1325 len = 127;
1326 }
1327 strncpy(str, (char *) (bytes+2), len);
1328 str[len] = '\0';
1329 printf("Utf8 \"%s\"", str);
1330 ent_size = 2 + len;
1331 break;
1332 }
1333 case JVM_CONSTANT_Integer: {
1334 u4 val = Bytes::get_Java_u4(bytes);
1335 printf("int %d", *(int *) &val);
1336 ent_size = 4;
1337 break;
1338 }
1339 case JVM_CONSTANT_Float: {
1340 u4 val = Bytes::get_Java_u4(bytes);
1341 printf("float %5.3ff", *(float *) &val);
1342 ent_size = 4;
1343 break;
1344 }
1345 case JVM_CONSTANT_Long: {
1346 u8 val = Bytes::get_Java_u8(bytes);
1347 printf("long "INT64_FORMAT, *(jlong *) &val);
1348 ent_size = 8;
1349 idx++; // Long takes two cpool slots
1350 break;
1351 }
1352 case JVM_CONSTANT_Double: {
1353 u8 val = Bytes::get_Java_u8(bytes);
1354 printf("double %5.3fd", *(jdouble *)&val);
1355 ent_size = 8;
1356 idx++; // Double takes two cpool slots
1357 break;
1358 }
1359 case JVM_CONSTANT_Class: {
1360 idx1 = Bytes::get_Java_u2(bytes);
1361 printf("class #%03d", idx1);
1362 ent_size = 2;
1363 break;
1364 }
1365 case JVM_CONSTANT_String: {
1366 idx1 = Bytes::get_Java_u2(bytes);
1367 printf("String #%03d", idx1);
1368 ent_size = 2;
1369 break;
1370 }
1371 case JVM_CONSTANT_Fieldref: {
1372 idx1 = Bytes::get_Java_u2(bytes);
1373 idx2 = Bytes::get_Java_u2(bytes+2);
1374 printf("Field #%03d, #%03d", (int) idx1, (int) idx2);
1375 ent_size = 4;
1376 break;
1377 }
1378 case JVM_CONSTANT_Methodref: {
1379 idx1 = Bytes::get_Java_u2(bytes);
1380 idx2 = Bytes::get_Java_u2(bytes+2);
1381 printf("Method #%03d, #%03d", idx1, idx2);
1382 ent_size = 4;
1383 break;
1384 }
1385 case JVM_CONSTANT_InterfaceMethodref: {
1386 idx1 = Bytes::get_Java_u2(bytes);
1387 idx2 = Bytes::get_Java_u2(bytes+2);
1388 printf("InterfMethod #%03d, #%03d", idx1, idx2);
1389 ent_size = 4;
1390 break;
1391 }
1392 case JVM_CONSTANT_NameAndType: {
1393 idx1 = Bytes::get_Java_u2(bytes);
1394 idx2 = Bytes::get_Java_u2(bytes+2);
1395 printf("NameAndType #%03d, #%03d", idx1, idx2);
1396 ent_size = 4;
1397 break;
1398 }
1399 case JVM_CONSTANT_ClassIndex: {
1400 printf("ClassIndex %s", WARN_MSG);
1401 break;
1402 }
1403 case JVM_CONSTANT_UnresolvedClass: {
1404 printf("UnresolvedClass: %s", WARN_MSG);
1405 break;
1406 }
1407 case JVM_CONSTANT_UnresolvedClassInError: {
1408 printf("UnresolvedClassInErr: %s", WARN_MSG);
1409 break;
1410 }
1411 case JVM_CONSTANT_StringIndex: {
1412 printf("StringIndex: %s", WARN_MSG);
1413 break;
1414 }
1415 case JVM_CONSTANT_UnresolvedString: {
1416 printf("UnresolvedString: %s", WARN_MSG);
1417 break;
1418 }
1419 }
1420 printf(";\n");
1421 bytes += ent_size;
1422 size += ent_size;
1423 }
1424 printf("Cpool size: %d\n", size);
1425 fflush(0);
1426 return;
1427 } /* end print_cpool_bytes */
1430 // Returns size of constant pool entry.
1431 jint constantPoolOopDesc::cpool_entry_size(jint idx) {
1432 switch(tag_at(idx).value()) {
1433 case JVM_CONSTANT_Invalid:
1434 case JVM_CONSTANT_Unicode:
1435 return 1;
1437 case JVM_CONSTANT_Utf8:
1438 return 3 + symbol_at(idx)->utf8_length();
1440 case JVM_CONSTANT_Class:
1441 case JVM_CONSTANT_String:
1442 case JVM_CONSTANT_ClassIndex:
1443 case JVM_CONSTANT_UnresolvedClass:
1444 case JVM_CONSTANT_UnresolvedClassInError:
1445 case JVM_CONSTANT_StringIndex:
1446 case JVM_CONSTANT_UnresolvedString:
1447 case JVM_CONSTANT_MethodType:
1448 return 3;
1450 case JVM_CONSTANT_MethodHandle:
1451 return 4; //tag, ref_kind, ref_index
1453 case JVM_CONSTANT_Integer:
1454 case JVM_CONSTANT_Float:
1455 case JVM_CONSTANT_Fieldref:
1456 case JVM_CONSTANT_Methodref:
1457 case JVM_CONSTANT_InterfaceMethodref:
1458 case JVM_CONSTANT_NameAndType:
1459 return 5;
1461 case JVM_CONSTANT_InvokeDynamic:
1462 case JVM_CONSTANT_InvokeDynamicTrans:
1463 // u1 tag, u2 bsm, u2 nt
1464 return 5;
1466 case JVM_CONSTANT_Long:
1467 case JVM_CONSTANT_Double:
1468 return 9;
1469 }
1470 assert(false, "cpool_entry_size: Invalid constant pool entry tag");
1471 return 1;
1472 } /* end cpool_entry_size */
1475 // SymbolHashMap is used to find a constant pool index from a string.
1476 // This function fills in SymbolHashMaps, one for utf8s and one for
1477 // class names, returns size of the cpool raw bytes.
1478 jint constantPoolOopDesc::hash_entries_to(SymbolHashMap *symmap,
1479 SymbolHashMap *classmap) {
1480 jint size = 0;
1482 for (u2 idx = 1; idx < length(); idx++) {
1483 u2 tag = tag_at(idx).value();
1484 size += cpool_entry_size(idx);
1486 switch(tag) {
1487 case JVM_CONSTANT_Utf8: {
1488 Symbol* sym = symbol_at(idx);
1489 symmap->add_entry(sym, idx);
1490 DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
1491 break;
1492 }
1493 case JVM_CONSTANT_Class:
1494 case JVM_CONSTANT_UnresolvedClass:
1495 case JVM_CONSTANT_UnresolvedClassInError: {
1496 Symbol* sym = klass_name_at(idx);
1497 classmap->add_entry(sym, idx);
1498 DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
1499 break;
1500 }
1501 case JVM_CONSTANT_Long:
1502 case JVM_CONSTANT_Double: {
1503 idx++; // Both Long and Double take two cpool slots
1504 break;
1505 }
1506 }
1507 }
1508 return size;
1509 } /* end hash_utf8_entries_to */
1512 // Copy cpool bytes.
1513 // Returns:
1514 // 0, in case of OutOfMemoryError
1515 // -1, in case of internal error
1516 // > 0, count of the raw cpool bytes that have been copied
1517 int constantPoolOopDesc::copy_cpool_bytes(int cpool_size,
1518 SymbolHashMap* tbl,
1519 unsigned char *bytes) {
1520 u2 idx1, idx2;
1521 jint size = 0;
1522 jint cnt = length();
1523 unsigned char *start_bytes = bytes;
1525 for (jint idx = 1; idx < cnt; idx++) {
1526 u1 tag = tag_at(idx).value();
1527 jint ent_size = cpool_entry_size(idx);
1529 assert(size + ent_size <= cpool_size, "Size mismatch");
1531 *bytes = tag;
1532 DBG(printf("#%03hd tag=%03hd, ", idx, tag));
1533 switch(tag) {
1534 case JVM_CONSTANT_Invalid: {
1535 DBG(printf("JVM_CONSTANT_Invalid"));
1536 break;
1537 }
1538 case JVM_CONSTANT_Unicode: {
1539 assert(false, "Wrong constant pool tag: JVM_CONSTANT_Unicode");
1540 DBG(printf("JVM_CONSTANT_Unicode"));
1541 break;
1542 }
1543 case JVM_CONSTANT_Utf8: {
1544 Symbol* sym = symbol_at(idx);
1545 char* str = sym->as_utf8();
1546 // Warning! It's crashing on x86 with len = sym->utf8_length()
1547 int len = (int) strlen(str);
1548 Bytes::put_Java_u2((address) (bytes+1), (u2) len);
1549 for (int i = 0; i < len; i++) {
1550 bytes[3+i] = (u1) str[i];
1551 }
1552 DBG(printf("JVM_CONSTANT_Utf8: %s ", str));
1553 break;
1554 }
1555 case JVM_CONSTANT_Integer: {
1556 jint val = int_at(idx);
1557 Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1558 break;
1559 }
1560 case JVM_CONSTANT_Float: {
1561 jfloat val = float_at(idx);
1562 Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1563 break;
1564 }
1565 case JVM_CONSTANT_Long: {
1566 jlong val = long_at(idx);
1567 Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1568 idx++; // Long takes two cpool slots
1569 break;
1570 }
1571 case JVM_CONSTANT_Double: {
1572 jdouble val = double_at(idx);
1573 Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1574 idx++; // Double takes two cpool slots
1575 break;
1576 }
1577 case JVM_CONSTANT_Class:
1578 case JVM_CONSTANT_UnresolvedClass:
1579 case JVM_CONSTANT_UnresolvedClassInError: {
1580 *bytes = JVM_CONSTANT_Class;
1581 Symbol* sym = klass_name_at(idx);
1582 idx1 = tbl->symbol_to_value(sym);
1583 assert(idx1 != 0, "Have not found a hashtable entry");
1584 Bytes::put_Java_u2((address) (bytes+1), idx1);
1585 DBG(printf("JVM_CONSTANT_Class: idx=#%03hd, %s", idx1, sym->as_utf8()));
1586 break;
1587 }
1588 case JVM_CONSTANT_String: {
1589 unsigned int hash;
1590 char *str = string_at_noresolve(idx);
1591 TempNewSymbol sym = SymbolTable::lookup_only(str, (int) strlen(str), hash);
1592 if (sym == NULL) {
1593 // sym can be NULL if string refers to incorrectly encoded JVM_CONSTANT_Utf8
1594 // this can happen with JVM TI; see CR 6839599 for more details
1595 oop string = *(obj_at_addr_raw(idx));
1596 assert(java_lang_String::is_instance(string),"Not a String");
1597 DBG(printf("Error #%03hd tag=%03hd\n", idx, tag));
1598 idx1 = 0;
1599 for (int j = 0; j < tbl->table_size() && idx1 == 0; j++) {
1600 for (SymbolHashMapEntry* cur = tbl->bucket(j); cur != NULL; cur = cur->next()) {
1601 int length;
1602 Symbol* s = cur->symbol();
1603 jchar* chars = s->as_unicode(length);
1604 if (java_lang_String::equals(string, chars, length)) {
1605 idx1 = cur->value();
1606 DBG(printf("Index found: %d\n",idx1));
1607 break;
1608 }
1609 }
1610 }
1611 } else {
1612 idx1 = tbl->symbol_to_value(sym);
1613 }
1614 assert(idx1 != 0, "Have not found a hashtable entry");
1615 Bytes::put_Java_u2((address) (bytes+1), idx1);
1616 DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, str));
1617 break;
1618 }
1619 case JVM_CONSTANT_UnresolvedString: {
1620 *bytes = JVM_CONSTANT_String;
1621 Symbol* sym = unresolved_string_at(idx);
1622 idx1 = tbl->symbol_to_value(sym);
1623 assert(idx1 != 0, "Have not found a hashtable entry");
1624 Bytes::put_Java_u2((address) (bytes+1), idx1);
1625 DBG(char *str = sym->as_utf8());
1626 DBG(printf("JVM_CONSTANT_UnresolvedString: idx=#%03hd, %s", idx1, str));
1627 break;
1628 }
1629 case JVM_CONSTANT_Fieldref:
1630 case JVM_CONSTANT_Methodref:
1631 case JVM_CONSTANT_InterfaceMethodref: {
1632 idx1 = uncached_klass_ref_index_at(idx);
1633 idx2 = uncached_name_and_type_ref_index_at(idx);
1634 Bytes::put_Java_u2((address) (bytes+1), idx1);
1635 Bytes::put_Java_u2((address) (bytes+3), idx2);
1636 DBG(printf("JVM_CONSTANT_Methodref: %hd %hd", idx1, idx2));
1637 break;
1638 }
1639 case JVM_CONSTANT_NameAndType: {
1640 idx1 = name_ref_index_at(idx);
1641 idx2 = signature_ref_index_at(idx);
1642 Bytes::put_Java_u2((address) (bytes+1), idx1);
1643 Bytes::put_Java_u2((address) (bytes+3), idx2);
1644 DBG(printf("JVM_CONSTANT_NameAndType: %hd %hd", idx1, idx2));
1645 break;
1646 }
1647 case JVM_CONSTANT_ClassIndex: {
1648 *bytes = JVM_CONSTANT_Class;
1649 idx1 = klass_index_at(idx);
1650 Bytes::put_Java_u2((address) (bytes+1), idx1);
1651 DBG(printf("JVM_CONSTANT_ClassIndex: %hd", idx1));
1652 break;
1653 }
1654 case JVM_CONSTANT_StringIndex: {
1655 *bytes = JVM_CONSTANT_String;
1656 idx1 = string_index_at(idx);
1657 Bytes::put_Java_u2((address) (bytes+1), idx1);
1658 DBG(printf("JVM_CONSTANT_StringIndex: %hd", idx1));
1659 break;
1660 }
1661 case JVM_CONSTANT_MethodHandle: {
1662 *bytes = JVM_CONSTANT_MethodHandle;
1663 int kind = method_handle_ref_kind_at(idx);
1664 idx1 = method_handle_index_at(idx);
1665 *(bytes+1) = (unsigned char) kind;
1666 Bytes::put_Java_u2((address) (bytes+2), idx1);
1667 DBG(printf("JVM_CONSTANT_MethodHandle: %d %hd", kind, idx1));
1668 break;
1669 }
1670 case JVM_CONSTANT_MethodType: {
1671 *bytes = JVM_CONSTANT_MethodType;
1672 idx1 = method_type_index_at(idx);
1673 Bytes::put_Java_u2((address) (bytes+1), idx1);
1674 DBG(printf("JVM_CONSTANT_MethodType: %hd", idx1));
1675 break;
1676 }
1677 case JVM_CONSTANT_InvokeDynamicTrans:
1678 case JVM_CONSTANT_InvokeDynamic: {
1679 *bytes = tag;
1680 idx1 = extract_low_short_from_int(*int_at_addr(idx));
1681 idx2 = extract_high_short_from_int(*int_at_addr(idx));
1682 assert(idx2 == invoke_dynamic_name_and_type_ref_index_at(idx), "correct half of u4");
1683 Bytes::put_Java_u2((address) (bytes+1), idx1);
1684 Bytes::put_Java_u2((address) (bytes+3), idx2);
1685 DBG(printf("JVM_CONSTANT_InvokeDynamic: %hd %hd", idx1, idx2));
1686 break;
1687 }
1688 }
1689 DBG(printf("\n"));
1690 bytes += ent_size;
1691 size += ent_size;
1692 }
1693 assert(size == cpool_size, "Size mismatch");
1695 // Keep temorarily for debugging until it's stable.
1696 DBG(print_cpool_bytes(cnt, start_bytes));
1697 return (int)(bytes - start_bytes);
1698 } /* end copy_cpool_bytes */
1701 void SymbolHashMap::add_entry(Symbol* sym, u2 value) {
1702 char *str = sym->as_utf8();
1703 unsigned int hash = compute_hash(str, sym->utf8_length());
1704 unsigned int index = hash % table_size();
1706 // check if already in map
1707 // we prefer the first entry since it is more likely to be what was used in
1708 // the class file
1709 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
1710 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
1711 if (en->hash() == hash && en->symbol() == sym) {
1712 return; // already there
1713 }
1714 }
1716 SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
1717 entry->set_next(bucket(index));
1718 _buckets[index].set_entry(entry);
1719 assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
1720 }
1722 SymbolHashMapEntry* SymbolHashMap::find_entry(Symbol* sym) {
1723 assert(sym != NULL, "SymbolHashMap::find_entry - symbol is NULL");
1724 char *str = sym->as_utf8();
1725 int len = sym->utf8_length();
1726 unsigned int hash = SymbolHashMap::compute_hash(str, len);
1727 unsigned int index = hash % table_size();
1728 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
1729 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
1730 if (en->hash() == hash && en->symbol() == sym) {
1731 return en;
1732 }
1733 }
1734 return NULL;
1735 }