Mercurial > hg > truffle
annotate src/share/vm/classfile/symbolTable.hpp @ 4181:319860ae697a
Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.
author | Christian Wimmer <Christian.Wimmer@Oracle.com> |
---|---|
date | Mon, 02 Jan 2012 14:16:08 -0800 |
parents | 352622fd140a |
children | 94ec88ca68e2 |
rev | line source |
---|---|
0 | 1 /* |
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2378
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP |
26 #define SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP | |
27 | |
28 #include "memory/allocation.inline.hpp" | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
29 #include "oops/symbol.hpp" |
1972 | 30 #include "utilities/hashtable.hpp" |
31 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
32 // The symbol table holds all Symbol*s and corresponding interned strings. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
33 // Symbol*s and literal strings should be canonicalized. |
0 | 34 // |
35 // The interned strings are created lazily. | |
36 // | |
37 // It is implemented as an open hash table with a fixed number of buckets. | |
38 // | |
39 // %note: | |
40 // - symbolTableEntrys are allocated in blocks to reduce the space overhead. | |
41 | |
42 class BoolObjectClosure; | |
43 | |
44 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
45 // Class to hold a newly created or referenced Symbol* temporarily in scope. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
46 // new_symbol() and lookup() will create a Symbol* if not already in the |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
47 // symbol table and add to the symbol's reference count. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
48 // probe() and lookup_only() will increment the refcount if symbol is found. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
49 class TempNewSymbol : public StackObj { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
50 Symbol* _temp; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
51 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
52 public: |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
53 TempNewSymbol() : _temp(NULL) {} |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
54 // Creating or looking up a symbol increments the symbol's reference count |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
55 TempNewSymbol(Symbol *s) : _temp(s) {} |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
56 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
57 // Operator= increments reference count. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
58 void operator=(const TempNewSymbol &s) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
59 _temp = s._temp; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
60 if (_temp !=NULL) _temp->increment_refcount(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
61 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
62 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
63 // Decrement reference counter so it can go away if it's unique |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
64 ~TempNewSymbol() { if (_temp != NULL) _temp->decrement_refcount(); } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
65 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
66 // Operators so they can be used like Symbols |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
67 Symbol* operator -> () const { return _temp; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
68 bool operator == (Symbol* o) const { return _temp == o; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
69 // Sneaky conversion function |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
70 operator Symbol*() { return _temp; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
71 }; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
72 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
73 class SymbolTable : public Hashtable<Symbol*> { |
0 | 74 friend class VMStructs; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
75 friend class ClassFileParser; |
0 | 76 |
77 private: | |
78 // The symbol table | |
79 static SymbolTable* _the_table; | |
80 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
81 // For statistics |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
82 static int symbols_removed; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
83 static int symbols_counted; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
84 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
85 Symbol* allocate_symbol(const u1* name, int len, TRAPS); // Assumes no characters larger than 0x7F |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
86 bool allocate_symbols(int names_count, const u1** names, int* lengths, Symbol** syms, TRAPS); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
87 |
0 | 88 // Adding elements |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
89 Symbol* basic_add(int index, u1* name, int len, |
0 | 90 unsigned int hashValue, TRAPS); |
91 bool basic_add(constantPoolHandle cp, int names_count, | |
92 const char** names, int* lengths, int* cp_indices, | |
93 unsigned int* hashValues, TRAPS); | |
94 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
95 static void new_symbols(constantPoolHandle cp, int names_count, |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
96 const char** name, int* lengths, |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
97 int* cp_indices, unsigned int* hashValues, |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
98 TRAPS) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
99 add(cp, names_count, name, lengths, cp_indices, hashValues, THREAD); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
100 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
101 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
102 |
0 | 103 // Table size |
104 enum { | |
105 symbol_table_size = 20011 | |
106 }; | |
107 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
108 Symbol* lookup(int index, const char* name, int len, unsigned int hash); |
0 | 109 |
110 SymbolTable() | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
111 : Hashtable<Symbol*>(symbol_table_size, sizeof (HashtableEntry<Symbol*>)) {} |
0 | 112 |
113 SymbolTable(HashtableBucket* t, int number_of_entries) | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
114 : Hashtable<Symbol*>(symbol_table_size, sizeof (HashtableEntry<Symbol*>), t, |
0 | 115 number_of_entries) {} |
116 | |
117 | |
118 public: | |
119 enum { | |
120 symbol_alloc_batch_size = 8 | |
121 }; | |
122 | |
123 // The symbol table | |
124 static SymbolTable* the_table() { return _the_table; } | |
125 | |
126 static void create_table() { | |
127 assert(_the_table == NULL, "One symbol table allowed."); | |
128 _the_table = new SymbolTable(); | |
129 } | |
130 | |
131 static void create_table(HashtableBucket* t, int length, | |
132 int number_of_entries) { | |
133 assert(_the_table == NULL, "One symbol table allowed."); | |
134 assert(length == symbol_table_size * sizeof(HashtableBucket), | |
135 "bad shared symbol size."); | |
136 _the_table = new SymbolTable(t, number_of_entries); | |
137 } | |
138 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
139 static Symbol* lookup(const char* name, int len, TRAPS); |
0 | 140 // lookup only, won't add. Also calculate hash. |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
141 static Symbol* lookup_only(const char* name, int len, unsigned int& hash); |
0 | 142 // Only copy to C string to be added if lookup failed. |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
143 static Symbol* lookup(const Symbol* sym, int begin, int end, TRAPS); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
144 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
145 static void release(Symbol* sym); |
0 | 146 |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
147 // jchar (utf16) version of lookups |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
148 static Symbol* lookup_unicode(const jchar* name, int len, TRAPS); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
149 static Symbol* lookup_only_unicode(const jchar* name, int len, unsigned int& hash); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
150 |
0 | 151 static void add(constantPoolHandle cp, int names_count, |
152 const char** names, int* lengths, int* cp_indices, | |
153 unsigned int* hashValues, TRAPS); | |
154 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
155 // Release any dead symbols |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
156 static void unlink(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
157 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
158 // iterate over symbols |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
159 static void symbols_do(SymbolClosure *cl); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
160 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
161 // Symbol creation |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
162 static Symbol* new_symbol(const char* utf8_buffer, int length, TRAPS) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
163 assert(utf8_buffer != NULL, "just checking"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
164 return lookup(utf8_buffer, length, THREAD); |
0 | 165 } |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
166 static Symbol* new_symbol(const char* name, TRAPS) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
167 return new_symbol(name, (int)strlen(name), THREAD); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
168 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
169 static Symbol* new_symbol(const Symbol* sym, int begin, int end, TRAPS) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
170 assert(begin <= end && end <= sym->utf8_length(), "just checking"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
171 return lookup(sym, begin, end, THREAD); |
0 | 172 } |
173 | |
174 // Symbol lookup | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
175 static Symbol* lookup(int index, const char* name, int len, TRAPS); |
0 | 176 |
177 // Needed for preloading classes in signatures when compiling. | |
178 // Returns the symbol is already present in symbol table, otherwise | |
179 // NULL. NO ALLOCATION IS GUARANTEED! | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
180 static Symbol* probe(const char* name, int len) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
181 unsigned int ignore_hash; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
182 return lookup_only(name, len, ignore_hash); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
183 } |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
184 static Symbol* probe_unicode(const jchar* name, int len) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
185 unsigned int ignore_hash; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
186 return lookup_only_unicode(name, len, ignore_hash); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
187 } |
0 | 188 |
189 // Histogram | |
190 static void print_histogram() PRODUCT_RETURN; | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
191 static void print() PRODUCT_RETURN; |
0 | 192 |
193 // Debugging | |
194 static void verify(); | |
195 | |
196 // Sharing | |
197 static void copy_buckets(char** top, char*end) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
198 the_table()->Hashtable<Symbol*>::copy_buckets(top, end); |
0 | 199 } |
200 static void copy_table(char** top, char*end) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
201 the_table()->Hashtable<Symbol*>::copy_table(top, end); |
0 | 202 } |
203 static void reverse(void* boundary = NULL) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
204 the_table()->Hashtable<Symbol*>::reverse(boundary); |
0 | 205 } |
206 }; | |
207 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
208 class StringTable : public Hashtable<oop> { |
0 | 209 friend class VMStructs; |
210 | |
211 private: | |
212 // The string table | |
213 static StringTable* _the_table; | |
214 | |
215 static oop intern(Handle string_or_null, jchar* chars, int length, TRAPS); | |
216 oop basic_add(int index, Handle string_or_null, jchar* name, int len, | |
217 unsigned int hashValue, TRAPS); | |
218 | |
219 oop lookup(int index, jchar* chars, int length, unsigned int hashValue); | |
220 | |
2378 | 221 StringTable() : Hashtable<oop>((int)StringTableSize, |
222 sizeof (HashtableEntry<oop>)) {} | |
0 | 223 |
224 StringTable(HashtableBucket* t, int number_of_entries) | |
2378 | 225 : Hashtable<oop>((int)StringTableSize, sizeof (HashtableEntry<oop>), t, |
226 number_of_entries) {} | |
0 | 227 |
228 public: | |
229 // The string table | |
230 static StringTable* the_table() { return _the_table; } | |
231 | |
232 static void create_table() { | |
233 assert(_the_table == NULL, "One string table allowed."); | |
234 _the_table = new StringTable(); | |
235 } | |
236 | |
237 static void create_table(HashtableBucket* t, int length, | |
238 int number_of_entries) { | |
239 assert(_the_table == NULL, "One string table allowed."); | |
2378 | 240 assert((size_t)length == StringTableSize * sizeof(HashtableBucket), |
0 | 241 "bad shared string size."); |
242 _the_table = new StringTable(t, number_of_entries); | |
243 } | |
244 | |
245 // GC support | |
246 // Delete pointers to otherwise-unreachable objects. | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
247 static void unlink(BoolObjectClosure* cl); |
0 | 248 |
249 // Invoke "f->do_oop" on the locations of all oops in the table. | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
250 static void oops_do(OopClosure* f); |
0 | 251 |
252 // Probing | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
253 static oop lookup(Symbol* symbol); |
0 | 254 |
255 // Interning | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
256 static oop intern(Symbol* symbol, TRAPS); |
0 | 257 static oop intern(oop string, TRAPS); |
258 static oop intern(const char *utf8_string, TRAPS); | |
259 | |
260 // Debugging | |
261 static void verify(); | |
262 | |
263 // Sharing | |
264 static void copy_buckets(char** top, char*end) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
265 the_table()->Hashtable<oop>::copy_buckets(top, end); |
0 | 266 } |
267 static void copy_table(char** top, char*end) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
268 the_table()->Hashtable<oop>::copy_table(top, end); |
0 | 269 } |
270 static void reverse() { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
271 the_table()->Hashtable<oop>::reverse(); |
0 | 272 } |
273 }; | |
1972 | 274 |
275 #endif // SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP |