316 oop entry = *(obj_at_addr(which));
317 if (entry->is_klass()) {
318 // Already resolved - return entry's name.
319 return klassOop(entry)->klass_part()->name();
320 } else {
321 assert(entry->is_symbol(), "must be either symbol or klass");
322 return (symbolOop)entry;
323 }
324 }
325
326 symbolOop constantPoolOopDesc::klass_ref_at_noresolve(int which) {
327 jint ref_index = klass_ref_index_at(which);
328 return klass_at_noresolve(ref_index);
329 }
330
331 char* constantPoolOopDesc::string_at_noresolve(int which) {
332 // Test entry type in case string is resolved while in here.
333 oop entry = *(obj_at_addr(which));
334 if (entry->is_symbol()) {
335 return ((symbolOop)entry)->as_C_string();
336 } else {
337 return java_lang_String::as_utf8_string(entry);
338 }
339 }
340
341
342 symbolOop constantPoolOopDesc::name_ref_at(int which) {
343 jint ref_index = name_and_type_at(name_and_type_ref_index_at(which));
344 int name_index = extract_low_short_from_int(ref_index);
345 return symbol_at(name_index);
346 }
347
348
349 symbolOop constantPoolOopDesc::signature_ref_at(int which) {
350 jint ref_index = name_and_type_at(name_and_type_ref_index_at(which));
351 int signature_index = extract_high_short_from_int(ref_index);
352 return symbol_at(signature_index);
353 }
354
355
356 BasicType constantPoolOopDesc::basic_type_for_signature_at(int which) {
357 return FieldType::basic_type(symbol_at(which));
358 }
359
360
361 void constantPoolOopDesc::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
362 for (int index = 1; index < this_oop->length(); index++) { // Index 0 is unused
363 if (this_oop->tag_at(index).is_unresolved_string()) {
364 this_oop->string_at(index, CHECK);
365 }
366 }
367 }
368
369 oop constantPoolOopDesc::string_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
370 oop entry = *(this_oop->obj_at_addr(which));
371 if (entry->is_symbol()) {
372 ObjectLocker ol(this_oop, THREAD);
373 if (this_oop->tag_at(which).is_unresolved_string()) {
374 // Intern string
375 symbolOop sym = this_oop->unresolved_string_at(which);
376 entry = StringTable::intern(sym, CHECK_(constantPoolOop(NULL)));
377 this_oop->string_at_put(which, entry);
378 } else {
379 // Another thread beat us and interned string, read string from constant pool
380 entry = this_oop->resolved_string_at(which);
381 }
382 }
383 assert(java_lang_String::is_instance(entry), "must be string");
384 return entry;
385 }
386
387
388 bool constantPoolOopDesc::klass_name_at_matches(instanceKlassHandle k,
389 int which) {
390 // Names are interned, so we can compare symbolOops directly
391 symbolOop cp_name = klass_name_at(which);
392 return (cp_name == k->name());
393 }
394
395
396 int constantPoolOopDesc::pre_resolve_shared_klasses(TRAPS) {
397 ResourceMark rm;
398 int count = 0;
399 for (int index = 1; index < tags()->length(); index++) { // Index 0 is unused
400 if (tag_at(index).is_unresolved_string()) {
401 // Intern string
402 symbolOop sym = unresolved_string_at(index);
403 oop entry = StringTable::intern(sym, CHECK_(-1));
404 string_at_put(index, entry);
405 }
406 }
|
316 oop entry = *(obj_at_addr(which));
317 if (entry->is_klass()) {
318 // Already resolved - return entry's name.
319 return klassOop(entry)->klass_part()->name();
320 } else {
321 assert(entry->is_symbol(), "must be either symbol or klass");
322 return (symbolOop)entry;
323 }
324 }
325
326 symbolOop constantPoolOopDesc::klass_ref_at_noresolve(int which) {
327 jint ref_index = klass_ref_index_at(which);
328 return klass_at_noresolve(ref_index);
329 }
330
331 char* constantPoolOopDesc::string_at_noresolve(int which) {
332 // Test entry type in case string is resolved while in here.
333 oop entry = *(obj_at_addr(which));
334 if (entry->is_symbol()) {
335 return ((symbolOop)entry)->as_C_string();
336 } else if (java_lang_String::is_instance(entry)) {
337 return java_lang_String::as_utf8_string(entry);
338 } else {
339 assert(false, "pseudo-string");
340 return (char*)"<pseudo-string>";
341 }
342 }
343
344
345 symbolOop constantPoolOopDesc::name_ref_at(int which) {
346 jint ref_index = name_and_type_at(name_and_type_ref_index_at(which));
347 int name_index = extract_low_short_from_int(ref_index);
348 return symbol_at(name_index);
349 }
350
351
352 symbolOop constantPoolOopDesc::signature_ref_at(int which) {
353 jint ref_index = name_and_type_at(name_and_type_ref_index_at(which));
354 int signature_index = extract_high_short_from_int(ref_index);
355 return symbol_at(signature_index);
356 }
357
358
359 BasicType constantPoolOopDesc::basic_type_for_signature_at(int which) {
360 return FieldType::basic_type(symbol_at(which));
361 }
362
363
364 void constantPoolOopDesc::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
365 for (int index = 1; index < this_oop->length(); index++) { // Index 0 is unused
366 if (this_oop->tag_at(index).is_unresolved_string()) {
367 this_oop->string_at(index, CHECK);
368 }
369 }
370 }
371
372 oop constantPoolOopDesc::string_at_impl(constantPoolHandle this_oop, int which, bool pseudo_ok, TRAPS) {
373 oop entry = *(this_oop->obj_at_addr(which));
374 if (entry->is_symbol()) {
375 ObjectLocker ol(this_oop, THREAD);
376 if (this_oop->tag_at(which).is_unresolved_string()) {
377 // Intern string
378 symbolOop sym = this_oop->unresolved_string_at(which);
379 entry = StringTable::intern(sym, CHECK_(constantPoolOop(NULL)));
380 this_oop->string_at_put(which, entry);
381 } else {
382 // Another thread beat us and interned string, read string from constant pool
383 entry = this_oop->resolved_string_at(which);
384 }
385 }
386 if (!pseudo_ok)
387 assert(java_lang_String::is_instance(entry), "must be string");
388 return entry;
389 }
390
391
392 bool constantPoolOopDesc::is_pseudo_string_at(int which) {
393 oop entry = *(obj_at_addr(which));
394 if (entry->is_symbol())
395 // Not yet resolved, but it will resolve to a string.
396 return false;
397 else if (java_lang_String::is_instance(entry))
398 return false;
399 else
400 // truly pseudo
401 return true;
402 }
403
404
405 bool constantPoolOopDesc::klass_name_at_matches(instanceKlassHandle k,
406 int which) {
407 // Names are interned, so we can compare symbolOops directly
408 symbolOop cp_name = klass_name_at(which);
409 return (cp_name == k->name());
410 }
411
412
413 int constantPoolOopDesc::pre_resolve_shared_klasses(TRAPS) {
414 ResourceMark rm;
415 int count = 0;
416 for (int index = 1; index < tags()->length(); index++) { // Index 0 is unused
417 if (tag_at(index).is_unresolved_string()) {
418 // Intern string
419 symbolOop sym = unresolved_string_at(index);
420 oop entry = StringTable::intern(sym, CHECK_(-1));
421 string_at_put(index, entry);
422 }
423 }
|