jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/symbolTable.cpp

-:36d1d483d5d6
+:da91efe96a93
 Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) {
 assert (len <= Symbol::max_length(), "should be checked by caller");
 Symbol* sym;
-// Allocate symbols in the C heap when dumping shared spaces in case there
-// are temporary symbols we can remove.
+if (c_heap) {
-if (c_heap || DumpSharedSpaces) {
 // refcount starts as 1
+assert(!DumpSharedSpaces, "never allocate to C heap");
 sym = new (len, THREAD) Symbol(name, len, 1);
+assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted");
+} else {
+if (DumpSharedSpaces) {
+sym = new (len, ClassLoaderData::the_null_class_loader_data(), THREAD) Symbol(name, len, -1);
 } else {
 sym = new (len, arena(), THREAD) Symbol(name, len, -1);
 }
-assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted");
+}
 return sym;
 }
 void SymbolTable::initialize_symbols(int arena_alloc_size) {
 // Initialize the arena for global symbols, size passed in depends on CDS.
 // end of the bucket.
 if (entry->is_shared() && !use_alternate_hashcode()) {
 break;
 }
 Symbol* s = entry->literal();
-memory_total += s->object_size();
+memory_total += s->size();
 total++;
 assert(s != NULL, "just checking");
 // If reference count is zero, remove.
 if (s->refcount() == 0) {
 assert(!entry->is_shared(), "shared entries should be kept live");
 UNICODE::convert_to_utf8(name, utf16_length, chars);
 return lookup_only(chars, utf8_length, hash);
 }
 }
-void SymbolTable::add(Handle class_loader, constantPoolHandle cp,
+void SymbolTable::add(ClassLoaderData* loader_data, constantPoolHandle cp,
 int names_count,
 const char** names, int* lengths, int* cp_indices,
 unsigned int* hashValues, TRAPS) {
 // Grab SymbolTable_lock first.
 MutexLocker ml(SymbolTable_lock, THREAD);
 SymbolTable* table = the_table();
-bool added = table->basic_add(class_loader, cp, names_count, names, lengths,
+bool added = table->basic_add(loader_data, cp, names_count, names, lengths,
 cp_indices, hashValues, CHECK);
 if (!added) {
 // do it the hard way
 for (int i=0; i<names_count; i++) {
 int index = table->hash_to_index(hashValues[i]);
-bool c_heap = class_loader() != NULL;
+bool c_heap = !loader_data->is_the_null_class_loader_data();
 Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], hashValues[i], c_heap, CHECK);
 cp->symbol_at_put(cp_indices[i], sym);
 }
 }
 }
 return sym;
 }
 // This version of basic_add adds symbols in batch from the constant pool
 // parsing.
-bool SymbolTable::basic_add(Handle class_loader, constantPoolHandle cp,
+bool SymbolTable::basic_add(ClassLoaderData* loader_data, constantPoolHandle cp,
 int names_count,
 const char** names, int* lengths,
 int* cp_indices, unsigned int* hashValues,
 TRAPS) {
 cp->symbol_at_put(cp_indices[i], test);
 assert(test->refcount() != 0, "lookup should have incremented the count");
 } else {
 // Create a new symbol.  The null class loader is never unloaded so these
 // are allocated specially in a permanent arena.
-bool c_heap = class_loader() != NULL;
+bool c_heap = !loader_data->is_the_null_class_loader_data();
 Symbol* sym = allocate_symbol((const u1*)names[i], lengths[i], c_heap, CHECK_(false));
 assert(sym->equals(names[i], lengths[i]), "symbol must be properly initialized");  // why wouldn't it be???
 HashtableEntry<Symbol*, mtSymbol>* entry = new_entry(hashValue, sym);
 add_entry(index, entry);
 cp->symbol_at_put(cp_indices[i], sym);
 int memory_total = 0;
 int count = 0;
 for (i = 0; i < the_table()->table_size(); i++) {
 HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
 for ( ; p != NULL; p = p->next()) {
-memory_total += p->literal()->object_size();
+memory_total += p->literal()->size();
 count++;
 int counter = p->literal()->utf8_length();
 total += counter;
 if (counter < results_length) {
 results[counter]++;
 assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(),
 "proposed name of symbol must be stable");
 Handle string;
 // try to reuse the string if possible
-if (!string_or_null.is_null() && (!JavaObjectsInPerm || string_or_null()->is_perm())) {
+if (!string_or_null.is_null()) {
 string = string_or_null;
 } else {
-string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL);
+string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);
 }
 // Grab the StringTable_lock before getting the_table() because it could
 // change at safepoint.
 MutexLocker ml(StringTable_lock, THREAD);
 for (int i = 0; i < the_table()->table_size(); ++i) {
 HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
 for ( ; p != NULL; p = p->next()) {
 oop s = p->literal();
 guarantee(s != NULL, "interned string is NULL");
-guarantee(s->is_perm() || !JavaObjectsInPerm, "interned string not in permspace");
 unsigned int h = java_lang_String::hash_string(s);
 guarantee(p->hash() == h, "broken hash in string table entry");
 guarantee(the_table()->hash_to_index(h) == i,
 "wrong index in string table");
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/classfile/symbolTable.cpp

src/share/vm/classfile/symbolTable.cpp