/*

 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "memory/gcLocker.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/oop.inline2.hpp"

#include "runtime/mutexLocker.hpp"

#include "utilities/hashtable.inline.hpp"

// --------------------------------------------------------------------------

SymbolTable* SymbolTable::_the_table = NULL;

// Static arena for symbols that are not deallocated

Arena* SymbolTable::_arena = NULL;

Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) {

  // Don't allow symbols to be created which cannot fit in a Symbol*.

  if (len > Symbol::max_length()) {

    THROW_MSG_0(vmSymbols::java_lang_InternalError(),

                "name is too long to represent");

  }

  Symbol* sym;

  // Allocate symbols in the C heap when dumping shared spaces in case there

  // are temporary symbols we can remove.

  if (c_heap || DumpSharedSpaces) {

    // refcount starts as 1

    sym = new (len, 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.

  if (arena_alloc_size == 0) {

    _arena = new Arena();

  } else {

    _arena = new Arena(arena_alloc_size);

  }

}

// Call function for all symbols in the symbol table.

void SymbolTable::symbols_do(SymbolClosure *cl) {

  const int n = the_table()->table_size();

  for (int i = 0; i < n; i++) {

    for (HashtableEntry<Symbol*>* p = the_table()->bucket(i);

         p != NULL;

         p = p->next()) {

      cl->do_symbol(p->literal_addr());

    }

  }

}

int SymbolTable::symbols_removed = 0;

int SymbolTable::symbols_counted = 0;

// Remove unreferenced symbols from the symbol table

// This is done late during GC.

void SymbolTable::unlink() {

  int removed = 0;

  int total = 0;

  size_t memory_total = 0;

  for (int i = 0; i < the_table()->table_size(); ++i) {

    for (HashtableEntry<Symbol*>** p = the_table()->bucket_addr(i); *p != NULL; ) {

      HashtableEntry<Symbol*>* entry = *p;

      if (entry->is_shared()) {

        break;

      }

      Symbol* s = entry->literal();

      memory_total += s->object_size();

      total++;

      assert(s != NULL, "just checking");

      // If reference count is zero, remove.

      if (s->refcount() == 0) {

        delete s;

        removed++;

        *p = entry->next();

        the_table()->free_entry(entry);

      } else {

        p = entry->next_addr();

      }

    }

  }

  symbols_removed += removed;

  symbols_counted += total;

  // Exclude printing for normal PrintGCDetails because people parse

  // this output.

  if (PrintGCDetails && Verbose && WizardMode) {

    gclog_or_tty->print(" [Symbols=%d size=" SIZE_FORMAT "K] ", total,

                        (memory_total*HeapWordSize)/1024);

  }

}

// Lookup a symbol in a bucket.

Symbol* SymbolTable::lookup(int index, const char* name,

                              int len, unsigned int hash) {

  for (HashtableEntry<Symbol*>* e = bucket(index); e != NULL; e = e->next()) {

    if (e->hash() == hash) {

      Symbol* sym = e->literal();

      if (sym->equals(name, len)) {

        // something is referencing this symbol now.

        sym->increment_refcount();

        return sym;

      }

    }

  }

  return NULL;

}

// We take care not to be blocking while holding the

// SymbolTable_lock. Otherwise, the system might deadlock, since the

// symboltable is used during compilation (VM_thread) The lock free

// synchronization is simplified by the fact that we do not delete

// entries in the symbol table during normal execution (only during

// safepoints).

Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) {

  unsigned int hashValue = hash_symbol(name, len);

  int index = the_table()->hash_to_index(hashValue);

  Symbol* s = the_table()->lookup(index, name, len, hashValue);

  // Found

  if (s != NULL) return s;

  // Otherwise, add to symbol to table

  return the_table()->basic_add(index, (u1*)name, len, hashValue, true, CHECK_NULL);

}

Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) {

  char* buffer;

  int index, len;

  unsigned int hashValue;

  char* name;

  {

    debug_only(No_Safepoint_Verifier nsv;)

    name = (char*)sym->base() + begin;

    len = end - begin;

    hashValue = hash_symbol(name, len);

    index = the_table()->hash_to_index(hashValue);

    Symbol* s = the_table()->lookup(index, name, len, hashValue);

    // Found

    if (s != NULL) return s;

  }

  // Otherwise, add to symbol to table. Copy to a C string first.

  char stack_buf[128];

  ResourceMark rm(THREAD);

  if (len <= 128) {

    buffer = stack_buf;

  } else {

    buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);

  }

  for (int i=0; i<len; i++) {

    buffer[i] = name[i];

  }

  // Make sure there is no safepoint in the code above since name can't move.

  // We can't include the code in No_Safepoint_Verifier because of the

  // ResourceMark.

  return the_table()->basic_add(index, (u1*)buffer, len, hashValue, true, CHECK_NULL);

}

Symbol* SymbolTable::lookup_only(const char* name, int len,

                                   unsigned int& hash) {

  hash = hash_symbol(name, len);

  int index = the_table()->hash_to_index(hash);

  Symbol* s = the_table()->lookup(index, name, len, hash);

  return s;

}

// Look up the address of the literal in the SymbolTable for this Symbol*

// Do not create any new symbols

// Do not increment the reference count to keep this alive

Symbol** SymbolTable::lookup_symbol_addr(Symbol* sym){

  unsigned int hash = hash_symbol((char*)sym->bytes(), sym->utf8_length());

  int index = the_table()->hash_to_index(hash);

  for (HashtableEntry<Symbol*>* e = the_table()->bucket(index); e != NULL; e = e->next()) {

    if (e->hash() == hash) {

      Symbol* literal_sym = e->literal();

      if (sym == literal_sym) {

        return e->literal_addr();

      }

    }

  }

  return NULL;

}

// Suggestion: Push unicode-based lookup all the way into the hashing

// and probing logic, so there is no need for convert_to_utf8 until

// an actual new Symbol* is created.

Symbol* SymbolTable::lookup_unicode(const jchar* name, int utf16_length, TRAPS) {

  int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);

  char stack_buf[128];

  if (utf8_length < (int) sizeof(stack_buf)) {

    char* chars = stack_buf;

    UNICODE::convert_to_utf8(name, utf16_length, chars);

    return lookup(chars, utf8_length, THREAD);

  } else {

    ResourceMark rm(THREAD);

    char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);;

    UNICODE::convert_to_utf8(name, utf16_length, chars);

    return lookup(chars, utf8_length, THREAD);

  }

}

Symbol* SymbolTable::lookup_only_unicode(const jchar* name, int utf16_length,

                                           unsigned int& hash) {

  int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);

  char stack_buf[128];

  if (utf8_length < (int) sizeof(stack_buf)) {

    char* chars = stack_buf;

    UNICODE::convert_to_utf8(name, utf16_length, chars);

    return lookup_only(chars, utf8_length, hash);

  } else {

    ResourceMark rm;

    char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);;

    UNICODE::convert_to_utf8(name, utf16_length, chars);

    return lookup_only(chars, utf8_length, hash);

  }

}

void SymbolTable::add(Handle class_loader, constantPoolHandle cp,

                      int names_count,

                      const char** names, int* lengths, int* cp_indices,

                      unsigned int* hashValues, TRAPS) {

  SymbolTable* table = the_table();

  bool added = table->basic_add(class_loader, 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;

      Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], hashValues[i], c_heap, CHECK);

      cp->symbol_at_put(cp_indices[i], sym);

    }

  }

}

Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) {

  unsigned int hash;

  Symbol* result = SymbolTable::lookup_only((char*)name, (int)strlen(name), hash);

  if (result != NULL) {

    return result;

  }

  SymbolTable* table = the_table();

  int index = table->hash_to_index(hash);

  return table->basic_add(index, (u1*)name, (int)strlen(name), hash, false, THREAD);

}

Symbol* SymbolTable::basic_add(int index, u1 *name, int len,

  assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(),

         "proposed name of symbol must be stable");

  // Grab SymbolTable_lock first.

  MutexLocker ml(SymbolTable_lock, THREAD);

  // Since look-up was done lock-free, we need to check if another

  // thread beat us in the race to insert the symbol.

  Symbol* test = lookup(index, (char*)name, len, hashValue);

  if (test != NULL) {

    // A race occurred and another thread introduced the symbol.

    assert(test->refcount() != 0, "lookup should have incremented the count");

    return test;

  }

  // Create a new symbol.

  Symbol* sym = allocate_symbol(name, len, c_heap, CHECK_NULL);

  assert(sym->equals((char*)name, len), "symbol must be properly initialized");

  HashtableEntry<Symbol*>* entry = new_entry(hashValue, sym);

  add_entry(index, entry);

  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,

                            int names_count,

                            const char** names, int* lengths,

                            int* cp_indices, unsigned int* hashValues,

                            TRAPS) {

  // Check symbol names are not too long.  If any are too long, don't add any.

  for (int i = 0; i< names_count; i++) {

    if (lengths[i] > Symbol::max_length()) {

      THROW_MSG_0(vmSymbols::java_lang_InternalError(),

                  "name is too long to represent");

    }

  }

  // Hold SymbolTable_lock through the symbol creation

  MutexLocker ml(SymbolTable_lock, THREAD);

  for (int i=0; i<names_count; i++) {

    // Since look-up was done lock-free, we need to check if another

    // thread beat us in the race to insert the symbol.

    if (test != NULL) {

      // A race occurred and another thread introduced the symbol, this one

      // will be dropped and collected. Use test instead.

      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;

      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???

      add_entry(index, entry);

      cp->symbol_at_put(cp_indices[i], sym);

    }

  }

  return true;

}

void SymbolTable::verify() {

  for (int i = 0; i < the_table()->table_size(); ++i) {

    HashtableEntry<Symbol*>* p = the_table()->bucket(i);

    for ( ; p != NULL; p = p->next()) {

      Symbol* s = (Symbol*)(p->literal());

      guarantee(s != NULL, "symbol is NULL");

      unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length());

      guarantee(p->hash() == h, "broken hash in symbol table entry");

      guarantee(the_table()->hash_to_index(h) == i,

                "wrong index in symbol table");

    }

  }

}

//---------------------------------------------------------------------------

// Non-product code

#ifndef PRODUCT

void SymbolTable::print_histogram() {

  MutexLocker ml(SymbolTable_lock);

  const int results_length = 100;

  int results[results_length];

  int i,j;

  // initialize results to zero

  for (j = 0; j < results_length; j++) {

    results[j] = 0;

  }

  int total = 0;

  int max_symbols = 0;

  int out_of_range = 0;

  int memory_total = 0;

  int count = 0;

  for (i = 0; i < the_table()->table_size(); i++) {

    HashtableEntry<Symbol*>* p = the_table()->bucket(i);

    for ( ; p != NULL; p = p->next()) {

      memory_total += p->literal()->object_size();

      count++;

      int counter = p->literal()->utf8_length();

      total += counter;

      if (counter < results_length) {

        results[counter]++;

      } else {

        out_of_range++;

      }

      max_symbols = MAX2(max_symbols, counter);

    }

  }

  tty->print_cr("Symbol Table:");

  tty->print_cr("Total number of symbols  %5d", count);

  tty->print_cr("Total size in memory     %5dK",

          (memory_total*HeapWordSize)/1024);

  tty->print_cr("Total counted            %5d", symbols_counted);

  tty->print_cr("Total removed            %5d", symbols_removed);

  if (symbols_counted > 0) {

    tty->print_cr("Percent removed          %3.2f",

          ((float)symbols_removed/(float)symbols_counted)* 100);

  }

  tty->print_cr("Reference counts         %5d", Symbol::_total_count);

  tty->print_cr("Symbol arena size        %5d used %5d",

                 arena()->size_in_bytes(), arena()->used());

  tty->print_cr("Histogram of symbol length:");

  tty->print_cr("%8s %5d", "Total  ", total);

  tty->print_cr("%8s %5d", "Maximum", max_symbols);

  tty->print_cr("%8s %3.2f", "Average",

          ((float) total / (float) the_table()->table_size()));

  tty->print_cr("%s", "Histogram:");

  tty->print_cr(" %s %29s", "Length", "Number chains that length");

  for (i = 0; i < results_length; i++) {