hotspot/src/share/vm/classfile/symbolTable.cpp
author twisti
Fri, 27 Feb 2009 13:27:09 -0800
changeset 2131 98f9cef66a34
parent 1 489c9b5090e2
child 2332 5c7b6f4ce0a1
permissions -rw-r--r--
6810672: Comment typos Summary: I have collected some typos I have found while looking at the code. Reviewed-by: kvn, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
# include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
# include "incls/_symbolTable.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// --------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
SymbolTable* SymbolTable::_the_table = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// Lookup a symbol in a bucket.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
symbolOop SymbolTable::lookup(int index, const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
                              int len, unsigned int hash) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  for (HashtableEntry* e = bucket(index); e != NULL; e = e->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
    if (e->hash() == hash) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
      symbolOop sym = symbolOop(e->literal());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
      if (sym->equals(name, len)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
        return sym;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// We take care not to be blocking while holding the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// SymbolTable_lock. Otherwise, the system might deadlock, since the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// symboltable is used during compilation (VM_thread) The lock free
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// synchronization is simplified by the fact that we do not delete
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// entries in the symbol table during normal execution (only during
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// safepoints).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
symbolOop SymbolTable::lookup(const char* name, int len, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  unsigned int hashValue = hash_symbol(name, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  int index = the_table()->hash_to_index(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  symbolOop s = the_table()->lookup(index, name, len, hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  // Found
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  if (s != NULL) return s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  // Otherwise, add to symbol to table
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  return the_table()->basic_add(index, (u1*)name, len, hashValue, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
symbolOop SymbolTable::lookup(symbolHandle sym, int begin, int end, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  char* buffer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  int index, len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  unsigned int hashValue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  char* name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    debug_only(No_Safepoint_Verifier nsv;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    name = (char*)sym->base() + begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    len = end - begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    hashValue = hash_symbol(name, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    index = the_table()->hash_to_index(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    symbolOop s = the_table()->lookup(index, name, len, hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    // Found
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    if (s != NULL) return s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  // Otherwise, add to symbol to table. Copy to a C string first.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  char stack_buf[128];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  if (len <= 128) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    buffer = stack_buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  for (int i=0; i<len; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    buffer[i] = name[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  // Make sure there is no safepoint in the code above since name can't move.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // We can't include the code in No_Safepoint_Verifier because of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // ResourceMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  return the_table()->basic_add(index, (u1*)buffer, len, hashValue, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
symbolOop SymbolTable::lookup_only(const char* name, int len,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
                                   unsigned int& hash) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  hash = hash_symbol(name, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  int index = the_table()->hash_to_index(hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  return the_table()->lookup(index, name, len, hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
void SymbolTable::add(constantPoolHandle cp, int names_count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
                      const char** names, int* lengths, int* cp_indices,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
                      unsigned int* hashValues, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  SymbolTable* table = the_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  bool added = table->basic_add(cp, names_count, names, lengths,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
                                cp_indices, hashValues, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  if (!added) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    // do it the hard way
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    for (int i=0; i<names_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
      int index = table->hash_to_index(hashValues[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      symbolOop sym = table->basic_add(index, (u1*)names[i], lengths[i],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
                                       hashValues[i], CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
      cp->symbol_at_put(cp_indices[i], sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
// Needed for preloading classes in signatures when compiling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
symbolOop SymbolTable::probe(const char* name, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  unsigned int hashValue = hash_symbol(name, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  int index = the_table()->hash_to_index(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  return the_table()->lookup(index, name, len, hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
symbolOop SymbolTable::basic_add(int index, u1 *name, int len,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
                                 unsigned int hashValue, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
         "proposed name of symbol must be stable");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // We assume that lookup() has been called already, that it failed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // and symbol was not found.  We create the symbol here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  symbolKlass* sk  = (symbolKlass*) Universe::symbolKlassObj()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  symbolOop s_oop = sk->allocate_symbol(name, len, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  symbolHandle sym (THREAD, s_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // Allocation must be done before grapping the SymbolTable_lock lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  MutexLocker ml(SymbolTable_lock, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  assert(sym->equals((char*)name, len), "symbol must be properly initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // Since look-up was done lock-free, we need to check if another
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // thread beat us in the race to insert the symbol.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  symbolOop test = lookup(index, (char*)name, len, hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  if (test != NULL) {
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1
diff changeset
   159
    // A race occurred and another thread introduced the symbol, this one
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    // will be dropped and collected.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    return test;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  HashtableEntry* entry = new_entry(hashValue, sym());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  add_entry(index, entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  return sym();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
bool SymbolTable::basic_add(constantPoolHandle cp, int names_count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
                            const char** names, int* lengths,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
                            int* cp_indices, unsigned int* hashValues,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
                            TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  symbolKlass* sk  = (symbolKlass*) Universe::symbolKlassObj()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  symbolOop sym_oops[symbol_alloc_batch_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  bool allocated = sk->allocate_symbols(names_count, names, lengths,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
                                        sym_oops, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  if (!allocated) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  symbolHandle syms[symbol_alloc_batch_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  for (i=0; i<names_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
    syms[i] = symbolHandle(THREAD, sym_oops[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // Allocation must be done before grabbing the SymbolTable_lock lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  MutexLocker ml(SymbolTable_lock, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  for (i=0; i<names_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    assert(syms[i]->equals(names[i], lengths[i]), "symbol must be properly initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    // Since look-up was done lock-free, we need to check if another
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    // thread beat us in the race to insert the symbol.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    int index = hash_to_index(hashValues[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    symbolOop test = lookup(index, names[i], lengths[i], hashValues[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    if (test != NULL) {
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1
diff changeset
   196
      // A race occurred and another thread introduced the symbol, this one
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
      // will be dropped and collected. Use test instead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
      cp->symbol_at_put(cp_indices[i], test);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
      symbolOop sym = syms[i]();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
      HashtableEntry* entry = new_entry(hashValues[i], sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
      add_entry(index, entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
      cp->symbol_at_put(cp_indices[i], sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
void SymbolTable::verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  for (int i = 0; i < the_table()->table_size(); ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    HashtableEntry* p = the_table()->bucket(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    for ( ; p != NULL; p = p->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
      symbolOop s = symbolOop(p->literal());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      guarantee(s != NULL, "symbol is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
      s->verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      guarantee(s->is_perm(), "symbol not in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
      unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
      guarantee(p->hash() == h, "broken hash in symbol table entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
      guarantee(the_table()->hash_to_index(h) == i,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
                "wrong index in symbol table");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
//---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
// Non-product code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
void SymbolTable::print_histogram() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  MutexLocker ml(SymbolTable_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  const int results_length = 100;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  int results[results_length];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  int i,j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // initialize results to zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  for (j = 0; j < results_length; j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    results[j] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  int total = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  int max_symbols = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  int out_of_range = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  for (i = 0; i < the_table()->table_size(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    HashtableEntry* p = the_table()->bucket(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
    for ( ; p != NULL; p = p->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
      int counter = symbolOop(p->literal())->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      total += counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
      if (counter < results_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
        results[counter]++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
        out_of_range++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
      max_symbols = MAX2(max_symbols, counter);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  tty->print_cr("Symbol Table:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  tty->print_cr("%8s %5d", "Total  ", total);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  tty->print_cr("%8s %5d", "Maximum", max_symbols);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  tty->print_cr("%8s %3.2f", "Average",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
          ((float) total / (float) the_table()->table_size()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  tty->print_cr("%s", "Histogram:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  tty->print_cr(" %s %29s", "Length", "Number chains that length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  for (i = 0; i < results_length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    if (results[i] > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
      tty->print_cr("%6d %10d", i, results[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  int line_length = 70;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  tty->print_cr("%s %30s", " Length", "Number chains that length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  for (i = 0; i < results_length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    if (results[i] > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
      tty->print("%4d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
      for (j = 0; (j < results[i]) && (j < line_length);  j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
        tty->print("%1s", "*");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
      if (j == line_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
        tty->print("%1s", "+");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
      tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  tty->print_cr(" %s %d: %d\n", "Number chains longer than",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
                    results_length, out_of_range);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
// --------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
class StableMemoryChecker : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  enum { _bufsize = wordSize*4 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  address _region;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  jint    _size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  u1      _save_buf[_bufsize];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  int sample(u1* save_buf) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    if (_size <= _bufsize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
      memcpy(save_buf, _region, _size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
      return _size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
      // copy head and tail
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
      memcpy(&save_buf[0],          _region,                      _bufsize/2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
      memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
      return (_bufsize/2)*2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  StableMemoryChecker(const void* region, jint size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    _region = (address) region;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    _size   = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    sample(_save_buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  bool verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    u1 check_buf[sizeof(_save_buf)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    int check_size = sample(check_buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    return (0 == memcmp(_save_buf, check_buf, check_size));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  void set_region(const void* region) { _region = (address) region; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
// --------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// Compute the hash value for a java.lang.String object which would
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
// contain the characters passed in. This hash value is used for at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
// least two purposes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
// (a) As the hash value used by the StringTable for bucket selection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
//     and comparison (stored in the HashtableEntry structures).  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
//     is used in the String.intern() method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
// (b) As the hash value used by the String object itself, in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
//     String.hashCode().  This value is normally calculate in Java code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
//     in the String.hashCode method(), but is precomputed for String
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
//     objects in the shared archive file.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
//     For this reason, THIS ALGORITHM MUST MATCH String.hashCode().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
int StringTable::hash_string(jchar* s, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  unsigned h = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  while (len-- > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    h = 31*h + (unsigned) *s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    s++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  return h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
StringTable* StringTable::_the_table = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
oop StringTable::lookup(int index, jchar* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
                        int len, unsigned int hash) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  for (HashtableEntry* l = bucket(index); l != NULL; l = l->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    if (l->hash() == hash) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
      if (java_lang_String::equals(l->literal(), name, len)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
        return l->literal();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
oop StringTable::basic_add(int index, Handle string_or_null, jchar* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
                           int len, unsigned int hashValue, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
         "proposed name of symbol must be stable");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  Handle string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // try to reuse the string if possible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  if (!string_or_null.is_null() && string_or_null()->is_perm()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    string = string_or_null;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // Allocation must be done before grapping the SymbolTable_lock lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  MutexLocker ml(StringTable_lock, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  assert(java_lang_String::equals(string(), name, len),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
         "string must be properly initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  // Since look-up was done lock-free, we need to check if another
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  // thread beat us in the race to insert the symbol.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  if (test != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    // Entry already added
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    return test;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  HashtableEntry* entry = new_entry(hashValue, string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  add_entry(index, entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  return string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
oop StringTable::lookup(symbolOop symbol) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  int length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  jchar* chars = symbol->as_unicode(length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  unsigned int hashValue = hash_string(chars, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  int index = the_table()->hash_to_index(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  return the_table()->lookup(index, chars, length, hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
oop StringTable::intern(Handle string_or_null, jchar* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
                        int len, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  unsigned int hashValue = hash_string(name, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  int index = the_table()->hash_to_index(hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  oop string = the_table()->lookup(index, name, len, hashValue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  // Found
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  if (string != NULL) return string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  // Otherwise, add to symbol to table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  return the_table()->basic_add(index, string_or_null, name, len,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
                                hashValue, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
oop StringTable::intern(symbolOop symbol, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  if (symbol == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  int length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  jchar* chars = symbol->as_unicode(length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  Handle string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  oop result = intern(string, chars, length, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
oop StringTable::intern(oop string, TRAPS)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  if (string == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  int length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  Handle h_string (THREAD, string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  jchar* chars = java_lang_String::as_unicode_string(string, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  oop result = intern(h_string, chars, length, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
oop StringTable::intern(const char* utf8_string, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  if (utf8_string == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  int length = UTF8::unicode_length(utf8_string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  jchar* chars = NEW_RESOURCE_ARRAY(jchar, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  UTF8::convert_to_unicode(utf8_string, chars, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  Handle string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  oop result = intern(string, chars, length, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
void StringTable::verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  for (int i = 0; i < the_table()->table_size(); ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    HashtableEntry* p = the_table()->bucket(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    for ( ; p != NULL; p = p->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
      oop s = p->literal();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
      guarantee(s != NULL, "interned string is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
      guarantee(s->is_perm(), "interned string not in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      int length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
      jchar* chars = java_lang_String::as_unicode_string(s, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
      unsigned int h = hash_string(chars, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      guarantee(p->hash() == h, "broken hash in string table entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
      guarantee(the_table()->hash_to_index(h) == i,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
                "wrong index in string table");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
}