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
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();
87   // The original attempt to resolve this constant pool entry failed so find the
111     // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
123           entry = this_oop->resolved_klass_at(which);
124           return (klassOop)entry.get_oop();
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();
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();
211     assert(entry.is_metadata(), "must be either symbol or klass");
213     Symbol* name = entry.get_symbol();
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();
254     assert(entry.is_metadata(), "must be either symbol or klass");
255     Symbol*  name  = entry.get_symbol();
305   ConstantPoolCacheEntry* e  = cpool->cache()->entry_at(cache_index);  // get next CPC entry
408   // A resolved constantPool entry will contain a klassOop, otherwise a Symbol*.
409   // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
411   CPSlot entry = slot_at(which);
412   if (entry.is_oop()) {
413     // Already resolved - return entry's name.
414     assert(entry.get_oop()->is_klass(), "must be");
415     return klassOop(entry.get_oop())->klass_part()->name();
417     assert(entry.is_metadata(), "must be either symbol or klass");
418     return entry.get_symbol();
433   // Test entry type in case string is resolved while in here.
434   CPSlot entry = slot_at(which);
435   if (entry.is_metadata()) {
436     return (entry.get_symbol())->as_C_string();
437   } else if (java_lang_String::is_instance(entry.get_oop())) {
438     return java_lang_String::as_utf8_string(entry.get_oop());
488         // Switch the query to use this CPC entry.
652     // The bootm, being a JVM_CONSTANT_MethodHandle, has its own cache entry.
685   CPSlot entry = this_oop->slot_at(which);
686   if (entry.is_metadata()) {
698     str = entry.get_oop();
706   CPSlot entry = slot_at(which);
707   if (entry.is_metadata())
710   else if (java_lang_String::is_instance(entry.get_oop()))
733       oop entry = StringTable::intern(sym, CHECK_(-1));
734       string_at_put(index, entry);
859 // Compare this constant pool's entry at index1 to the constant pool
860 // cp2's entry at index2.
878     // Not the same entry type so there is nothing else to check. Note
1067   // Invalid is used as the tag for the second constant pool entry
1101       // all others take one constant pool entry
1159 // Copy this constant pool's entry at from_i to the constant pool
1160 // to_cp's entry at to_i.
1183     // double takes two constant pool entries so init second entry's tag
1217     // long takes two constant pool entries so init second entry's tag
1250     CPSlot entry = from_cp->slot_at(from_i);
1251     if (entry.is_oop()) {
1252       assert(entry.get_oop()->is_klass(), "must be");
1254       to_cp->klass_at_put(to_i, (klassOop)entry.get_oop());
1256       to_cp->unresolved_klass_at_put(to_i, entry.get_symbol());
1271     CPSlot entry = from_cp->slot_at(from_i);
1272     if (entry.is_oop()) {
1274       to_cp->string_at_put(to_i, entry.get_oop());
1276       to_cp->unresolved_string_at_put(to_i, entry.get_symbol());
1309   // Invalid is used as the tag for the second constant pool entry
1322 // Search constant pool search_cp for an entry that matches this
1323 // constant pool's entry at pattern_i. Returns the index of a
1324 // matching entry or zero (0) if there is no matching entry.
1336   return 0;  // entry not found; return unused index zero (0)
1364 static const char* WARN_MSG = "Must not be such entry!";
1398         u4 val = Bytes::get_Java_u4(bytes);
1399         printf("int          %d", *(int *) &val);
1404         u4 val = Bytes::get_Java_u4(bytes);
1405         printf("float        %5.3ff", *(float *) &val);
1410         u8 val = Bytes::get_Java_u8(bytes);
1411         printf("long         "INT64_FORMAT, (int64_t) *(jlong *) &val);
1417         u8 val = Bytes::get_Java_u8(bytes);
1418         printf("double       %5.3fd", *(jdouble *)&val);
1494 // Returns size of constant pool entry.
1533   assert(false, "cpool_entry_size: Invalid constant pool entry tag");
1553         DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
1561         DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
1619         jint val = int_at(idx);
1620         Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1624         jfloat val = float_at(idx);
1625         Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1629         jlong val = long_at(idx);
1630         Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1635         jdouble val = double_at(idx);
1636         Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1646         assert(idx1 != 0, "Have not found a hashtable entry");
1677         assert(idx1 != 0, "Have not found a hashtable entry");
1686         assert(idx1 != 0, "Have not found a hashtable entry");
1769   // we prefer the first entry since it is more likely to be what was used in
1778   SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
1779   entry->set_next(bucket(index));
1780   _buckets[index].set_entry(entry);
1781   assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");

Indexes created Tue Jul 24 14:28:13 CEST 2018